Fuzzy Extractors: How to Generate Strong Keys from Biometrics and Other Noisy Data

We provide formal definitions and efficient secure techniques for

• turning noisy information into keys usable for any cryptographic application, and, in particular,

• reliably and securely authenticating biometric data.

Our techniques apply not just to biometric information, but to any keying material that, unlike traditional cryptographic keys, is (1) not reproducible precisely and (2) not distributed uniformly. We propose two primitives: a fuzzy extractor reliably extracts nearly uniform randomness $R$ from its input; the extraction is error-tolerant in the sense that $R$ will be the same even if the input changes, as long as it remains reasonably close to the original. Thus, $R$ can be used as a key in a cryptographic application. A secure sketch produces public information about its input $w$ that does not reveal $w$, and yet allows exact recovery of $w$ given another value that is close to $w$. Thus, it can be used to reliably reproduce error-prone biometric inputs without incurring the security risk inherent in storing them.

We define the primitives to be both formally secure and versatile, generalizing much prior work. In addition, we provide nearly optimal constructions of both primitives for various measures of “closeness” of input data, such as Hamming distance, edit distance, and set difference.

Key words.  fuzzy extractors, fuzzy fingerprints, randomness extractors, error-correcting codes, biometric authentication, error-tolerance, nonuniformity, password-based systems, metric embeddings

AMS subject classifications. 68P25, 68P30, 68Q99, 94A17, 94A60, 94B35, 94B99

1 Introduction

Cryptography traditionally relies on uniformly distributed and precisely reproducible random strings for its secrets. Reality, however, makes it difficult to create, store, and reliably retrieve such strings. Strings that are neither uniformly random nor reliably reproducible seem to be more plentiful. For example, a random person’s fingerprint or iris scan is clearly not a uniform random string, nor does it get reproduced precisely each time it is measured. Similarly, a long pass-phrase (or answers to 15 questions [FJ01] or a list of favorite movies [JS06]) is not uniformly random and is difficult to remember for a human user. This work is about using such nonuniform and unreliable secrets in cryptographic applications. Our approach is rigorous and general, and our results have both theoretical and practical value.

To illustrate the use of random strings on a simple example, let us consider the task of password authentication. A user Alice has a password $w$ and wants to gain access to her account. A trusted server stores some information $y=f(w)$ about the password. When Alice enters $w$, the server lets Alice in only if $f(w)=y$. In this simple application, we assume that it is safe for Alice to enter the password for the verification. However, the server’s long-term storage is not assumed to be secure (e.g., $y$ is stored in a publicly readable /etc/passwd file in UNIX [MT79]). The goal, then, is to design an efficient $f$ that is hard to invert (i.e., given $y$ it is hard to find $w^{\prime}$ such that $f(w^{\prime})=y$), so that no one can figure out Alice’s password from $y$. Recall that such functions $f$ are called one-way functions.

Unfortunately, the solution above has several problems when used with passwords $w$ available in real life. First, the definition of a one-way function assumes that $w$ is truly uniform and guarantees nothing if this is not the case. However, human-generated and biometric passwords are far from uniform, although they do have some unpredictability in them. Second, Alice has to reproduce her password exactly each time she authenticates herself. This restriction severely limits the kinds of passwords that can be used. Indeed, a human can precisely memorize and reliably type in only relatively short passwords, which do not provide an adequate level of security. Greater levels of security are achieved by longer human-generated and biometric passwords, such as pass-phrases, answers to questionnaires, handwritten signatures, fingerprints, retina scans, voice commands, and other values selected by humans or provided by nature, possibly in combination (see [Fry00] for a survey). These measurements seem to contain much more entropy than human-memorizable passwords. However, two biometric readings are rarely identical, even though they are likely to be close; similarly, humans are unlikely to precisely remember their answers to multiple questions from time to time, though such answers will likely be similar. In other words, the ability to tolerate a (limited) number of errors in the password while retaining security is crucial if we are to obtain greater security than provided by typical user-chosen short passwords.

The password authentication described above is just one example of a cryptographic application where the issues of nonuniformity and error-tolerance naturally come up. Other examples include any cryptographic application, such as encryption, signatures, or identification, where the secret key comes in the form of noisy nonuniform data.

Our Definitions.  As discussed above, an important general problem is to convert noisy nonuniform inputs into reliably reproducible, uniformly random strings. To this end, we propose a new primitive, termed fuzzy extractor. It extracts a uniformly random string $R$ from its input $w$ in a noise-tolerant way. Noise-tolerance means that if the input changes to some $w^{\prime}$ but remains close, the string $R$ can be reproduced exactly. To assist in reproducing $R$ from $w^{\prime}$, the fuzzy extractor outputs a nonsecret string $P$. It is important to note that $R$ remains uniformly random even given $P$. (Strictly speaking, $R$ will be $\epsilon$-close to uniform rather than uniform; $\epsilon$ can be made exponentially small, which makes $R$ as good as uniform for the usual applications.)

Our approach is general: $R$ extracted from $w$ can be used as a key in a cryptographic application but unlike traditional keys, need not be stored (because it can be recovered from any $w^{\prime}$ that is close to $w$). We define fuzzy extractors to be information-theoretically secure, thus allowing them to be used in cryptographic systems without introducing additional assumptions (of course, the cryptographic application itself will typically have computational, rather than information-theoretic, security).

For a concrete example of how to use fuzzy extractors, in the password authentication case, the server can store $(P,f(R))$. When the user inputs $w^{\prime}$ close to $w$, the server reproduces the actual $R$ using $P$ and checks if $f(R)$ matches what it stores. The presence of $P$ will help the adversary invert $f(R)$ only by the additive amount of $\epsilon$, because $R$ is $\epsilon$-close to uniform even given $P$. Similarly, $R$ can be used for symmetric encryption, for generating a public-secret key pair, or for other applications that utilize uniformly random secrets.

Figure 1: (a) secure sketch; (b) fuzzy extractor; (c) a sample application: user who encrypts a sensitive record using a cryptographically strong, uniform key $R$ extracted from biometric $w$ via a fuzzy extractor; both $P$ and the encrypted record need not be kept secret, because no one can decrypt the record without a $w^{\prime}$ that is close.

As a step in constructing fuzzy extractors, and as an interesting object in its own right, we propose another primitive, termed secure sketch. It allows precise reconstruction of a noisy input, as follows: on input $w$, a procedure outputs a sketch $s$. Then, given $s$ and a value $w^{\prime}$ close to $w$, it is possible to recover $w$. The sketch is secure in the sense that it does not reveal much about $w$: $w$ retains much of its entropy even if $s$ is known. Thus, instead of storing $w$ for fear that later readings will be noisy, it is possible to store $s$ instead, without compromising the privacy of $w$. A secure sketch, unlike a fuzzy extractor, allows for the precise reproduction of the original input, but does not address nonuniformity.

Secure sketches, fuzzy extractors and a sample encryption application are illustrated in Figure 1.

Secure sketches and extractors can be viewed as providing fuzzy key storage: they allow recovery of the secret key ($w$ or $R$) from a faulty reading $w^{\prime}$ of the password $w$ by using some public information ($s$ or $P$). In particular, fuzzy extractors can be viewed as error- and nonuniformity-tolerant secret key key-encapsulation mechanisms [Sho01].

Because different biometric information has different error patterns, we do not assume any particular notion of closeness between $w^{\prime}$ and $w$. Rather, in defining our primitives, we simply assume that $w$ comes from some metric space, and that $w^{\prime}$ is no more than a certain distance from $w$ in that space. We consider particular metrics only when building concrete constructions.

General Results.  Before proceeding to construct our primitives for concrete metrics, we make some observations about our definitions. We demonstrate that fuzzy extractors can be built out of secure sketches by utilizing strong randomness extractors [NZ96], such as, for example, universal hash functions [CW79, WC81] (randomness extractors, defined more precisely below, are families of hash which “convert” a high entropy input into a shorter, uniformly distributed output). We also provide a general technique for constructing secure sketches from transitive families of isometries, which is instantiated in concrete constructions later in the paper. Finally, we define a notion of a biometric embedding of one metric space into another and show that the existence of a fuzzy extractor in the target space, combined with a biometric embedding of the source into the target, implies the existence of a fuzzy extractor in the source space.

These general results help us in building and analyzing our constructions.

Our Constructions.  We provide constructions of secure sketches and fuzzy extractors in three metrics: Hamming distance, set difference, and edit distance. Unless stated otherwise, all the constructions are new.

Hamming distance (i.e., the number of symbol positions that differ between $w$ and $w^{\prime}$) is perhaps the most natural metric to consider. We observe that the “fuzzy-commitment” construction of Juels and Wattenberg [JW99] based on error-correcting codes can be viewed as a (nearly optimal) secure sketch. We then apply our general result to convert it into a nearly optimal fuzzy extractor. While our results on the Hamming distance essentially use previously known constructions, they serve as an important stepping stone for the rest of the work.

The set difference metric (i.e., size of the symmetric difference of two input sets $w$ and $w^{\prime}$) is appropriate whenever the noisy input is represented as a subset of features from a universe of possible features. We demonstrate the existence of optimal (with respect to entropy loss) secure sketches and fuzzy extractors for this metric. However, this result is mainly of theoretical interest, because (1) it relies on optimal constant-weight codes, which we do not know how to construct, and (2) it produces sketches of length proportional to the universe size. We then turn our attention to more efficient constructions for this metric in order to handle exponentially large universes. We provide two such constructions.

First, we observe that the “fuzzy vault” construction of Juels and Sudan [JS06] can be viewed as a secure sketch in this metric (and then converted to a fuzzy extractor using our general result). We provide a new, simpler analysis for this construction, which bounds the entropy lost from $w$ given $s$. This bound is quite high unless one makes the size of the output $s$ very large. We then improve the Juels-Sudan construction to reduce the entropy loss and the length of $s$ to near optimal. Our improvement in the running time and in the length of $s$ is exponential for large universe sizes. However, this improved Juels-Sudan construction retains a drawback of the original: it is able to handle only sets of the same fixed size (in particular, $|w^{\prime}|$ must equal $|w|$.)

Second, we provide an entirely different construction, called PinSketch, that maintains the exponential improvements in sketch size and running time and also handles variable set size. To obtain it, we note that in the case of a small universe, a set can be simply encoded as its characteristic vector (1 if an element is in the set, 0 if it is not), and set difference becomes Hamming distance. Even though the length of such a vector becomes unmanageable as the universe size grows, we demonstrate that this approach can be made to work quite efficiently even for exponentially large universes (in particular, because it is not necessary to ever actually write down the vector). This involves a result that may be of independent interest: we show that BCH codes can be decoded in time polynomial in the weight of the received corrupted word (i.e., in sublinear time if the weight is small).

Finally, edit distance (i.e., the number of insertions and deletions needed to convert one string into the other) comes up, for example, when the password is entered as a string, due to typing errors or mistakes made in handwriting recognition. We discuss two approaches for secure sketches and fuzzy extractors for this metric. First, we observe that a recent low-distortion embedding of Ostrovsky and Rabani [OR05] immediately gives a construction for edit distance. The construction performs well when the number of errors to be corrected is very small (say $n^{\alpha}$ for $\alpha<1$) but cannot tolerate a large number of errors. Second, we give a biometric embedding (which is less demanding than a low-distortion embedding, but suffices for obtaining fuzzy extractors) from the edit distance metric into the set difference metric. Composing it with a fuzzy extractor for set difference gives a different construction for edit distance, which does better when $t$ is large; it can handle as many as $O(n/\log^{2}n)$ errors with meaningful entropy loss.

Most of the above constructions are quite practical; some implementations are available [HJR06].

Extending Results for Probabilistic Notions of Correctness.  The definitions and constructions just described use a very strong error model: we require that secure sketches and fuzzy extractors accept every secret $w^{\prime}$ which is sufficiently close to the original secret $w$, with probability 1. Such a stringent model is useful, as it makes no assumptions on the stochastic and computational properties of the error process. However, slightly relaxing the error conditions allows constructions which tolerate a (provably) much larger number of errors, at the price of restricting the settings in which the constructions can be applied. In Section 8, we extend the definitions and constructions of earlier sections to several relaxed error models.

It is well-known that in the standard setting of error-correction for a binary communication channel, one can tolerate many more errors when the errors are random and independent than when the errors are determined adversarially. In contrast, we present fuzzy extractors that meet Shannon’s bounds for correcting random errors and, moreover, can correct the same number of errors even when errors are adversarial. In our setting, therefore, under a proper relaxation of the correctness condition, adversarial errors are no stronger than random ones. The constructions are quite simple and draw on existing techniques from the coding literature [BBR88, DGL04, Gur03, Lan04, MPSW05].

Relation to Previous Work.  Since our work combines elements of error correction, randomness extraction and password authentication, there has been a lot of related work.

The need to deal with nonuniform and low-entropy passwords has long been realized in the security community, and many approaches have been proposed. For example, Kelsey et al. [KSHW97] suggested using $f(w,r)$ in place of $w$ for the password authentication scenario, where $r$ is a public random “salt,” to make a brute-force attacker’s life harder. While practically useful, this approach does not add any entropy to the password and does not formally address the needed properties of $f$. Another approach, more closely related to ours, is to add biometric features to the password. For example, Ellison et al. [EHMS00] proposed asking the user a series of $n$ personalized questions and using these answers to encrypt the “actual” truly random secret $R$. A similar approach using the user’s keyboard dynamics (and, subsequently, voice [MRLW01a, MRLW01b]) was proposed by Monrose et al. [MRW99]. These approaches require the design of a secure “fuzzy encryption.” The above works proposed heuristic designs (using various forms of Shamir’s secret sharing), but gave no formal analysis. Additionally, error tolerance was addressed only by brute force search.

A formal approach to error tolerance in biometrics was taken by Juels and Wattenberg [JW99] (for less formal solutions, see [DFMP99, MRW99, EHMS00]), who provided a simple way to tolerate errors in uniformly distributed passwords. Frykholm and Juels [FJ01] extended this solution and provided entropy analysis to which ours is similar. Similar approaches have been explored earlier in seemingly unrelated literature on cryptographic information reconciliation, often in the context of quantum cryptography (where Alice and Bob wish to derive a secret key from secrets that have small Hamming distance), particularly [BBR88, BBCS91]. Our construction for the Hamming distance is essentially the same as a component of the quantum oblivious transfer protocol of [BBCS91].

Juels and Sudan [JS06] provided the first construction for a metric other than Hamming: they constructed a “fuzzy vault” scheme for the set difference metric. The main difference is that [JS06] lacks a cryptographically strong definition of the object constructed. In particular, their construction leaks a significant amount of information about their analog of $R$, even though it leaves the adversary with provably “many valid choices” for $R$. In retrospect, their informal notion is closely related to our secure sketches. Our constructions in Section 6 improve exponentially over the construction of [JS06] for storage and computation costs, in the setting when the set elements come from a large universe.

Linnartz and Tuyls [LT03] defined and constructed a primitive very similar to a fuzzy extractor (that line of work was continued in [VTDL03].) The definition of [LT03] focuses on the continuous space $\mathbb{R}^{n}$ and assumes a particular input distribution (typically a known, multivariate Gaussian). Thus, our definition of a fuzzy extractor can be viewed as a generalization of the notion of a “shielding function” from [LT03]. However, our constructions focus on discrete metric spaces.

Other approaches have also been taken for guaranteeing the privacy of noisy data. Csirmaz and Katona [CK03] considered quantization for correcting errors in “physical random functions.” (This corresponds roughly to secure sketches with no public storage.) Barral, Coron and Naccache [BCN04] proposed a system for offline, private comparison of fingerprints. Although seemingly similar, the problem they study is complementary to ours, and the two solutions can be combined to yield systems which enjoy the benefits of both.

Work on privacy amplification, e.g., [BBR88, BBCM95], as well as work on derandomization and hardness amplification, e.g., [HILL99, NZ96], also addressed the need to extract uniform randomness from a random variable about which some information has been leaked. A major focus of follow-up research has been the development of (ordinary, not fuzzy) extractors with short seeds (see [Sha02] for a survey). We use extractors in this work (though for our purposes, universal hashing is sufficient). Conversely, our work has been applied recently to privacy amplification: Ding [Din05] used fuzzy extractors for noise tolerance in Maurer’s bounded storage model [Mau93].

Independently of our work, similar techniques appeared in the literature on noncryptographic information reconciliation [MTZ03, CT04] (where the goal is communication efficiency rather than secrecy). The relationship between secure sketches and efficient information reconciliation is explored further in Section 9, which discusses, in particular, how our secure sketches for set differences provide more efficient solutions to the set and string reconciliation problems.

Follow-up Work.  Since the original presentation of this paper [DRS04], several follow-up works have appeared (e.g., [Boy04, BDK${}^{+}$05, DS05, DORS06, Smi07, CL06, LSM06, CFL06]). We refer the reader to a recent survey about fuzzy extractors [DRS07] for more information.

2 Preliminaries

Unless explicitly stated otherwise, all logarithms below are base $2$. The Hamming weight (or just weight) of a string is the number of nonzero characters in it. We use $U_{\ell}$ to denote the uniform distribution on $\ell$-bit binary strings. If an algorithm (or a function) $f$ is randomized, we use the semicolon when we wish to make the randomness explicit: i.e., we denote by $f(x;r)$ the result of computing $f$ on input $x$ with randomness $r$. If $X$ is a probability distribution, then $f(X)$ is the distribution induced on the image of $f$ by applying the (possibly probabilistic) function $f$. If $X$ is a random variable, we will (slightly) abuse notation and also denote by $X$ the probability distribution on the range of the variable.

2.1 Metric Spaces

A metric space is a set ${\cal M}$ with a distance function ${\mathsf{dis}}:{\cal M}\times{\cal M}\to\mathbb{R}^{+}=[0,\infty)$. For the purposes of this work, ${\cal M}$ will always be a finite set, and the distance function only take on only integer values (with ${\mathsf{dis}}(x,y)=0$ if and only if $x=y$) and will obey symmetry ${\mathsf{dis}}(x,y)={\mathsf{dis}}(y,x)$ and the triangle inequality ${\mathsf{dis}}(x,z)\leq{\mathsf{dis}}(x,y)+{\mathsf{dis}}(y,z)$ (we adopt these requirements for simplicity of exposition, even though the definitions and most of the results below can be generalized to remove these restrictions).

We will concentrate on the following metrics.

1. Hamming metric. Here ${\cal M}={\cal F}^{n}$ for some alphabet ${\cal F}$, and ${\mathsf{dis}(w,w^{\prime})}$ is the number of positions in which the strings $w$ and $w^{\prime}$ differ.

2. Set difference metric. Here ${\cal M}$ consists of all subsets of a universe ${\cal U}$. For two sets $w,w^{\prime}$, their symmetric difference $w\triangle w^{\prime}\stackrel{{\scriptstyle\rm def}}{{=}}\{x\in w\cup w^{\prime}\mid x\notin w\cap w^{\prime}\}$. The distance between two sets $w,w^{\prime}$ is $|w\triangle w^{\prime}|$.  We will sometimes restrict ${\cal M}$ to contain only $s$-element subsets for some $s$.

3. Edit metric. Here ${\cal M}={\cal F}^{*}$, and the distance between $w$ and $w^{\prime}$ is defined to be the smallest number of character insertions and deletions needed to transform $w$ into $w^{\prime}$.  (This is different from the Hamming metric because insertions and deletions shift the characters that are to the right of the insertion/deletion point.)

As already mentioned, all three metrics seem natural for biometric data.

2.2 Codes and Syndromes

Since we want to achieve error tolerance in various metric spaces, we will use error-correcting codes for a particular metric. A code $C$ is a subset $\left\{{w_{0},\ldots,w_{K-1}}\right\}$ of $K$ elements of ${\cal M}$. The map from $i$ to $w_{i}$, which we will also sometimes denote by $C$, is called encoding. The minimum distance of $C$ is the smallest $d>0$ such that for all $i\neq j$ we have ${\mathsf{dis}(w_{i},w_{j})}\geq d$. In our case of integer metrics, this means that one can detect up to $(d-1)$ “errors” in an element of ${\cal M}$. The error-correcting distance of $C$ is the largest number $t>0$ such that for every $w\in{\cal M}$ there exists at most one codeword $c$ in the ball of radius $t$ around $w$: ${\mathsf{dis}(w,c)}\leq t$ for at most one $c\in C$. This means that one can correct up to $t$ errors in an element $w$ of ${\cal M}$; we will use the term decoding for the map that finds, given $w$, the $c\in C$ such that ${\mathsf{dis}(w,c)}\leq t$ (note that for some $w$, such $c$ may not exist, but if it exists, it will be unique; note also that decoding is not the inverse of encoding in our terminology). For integer metrics by triangle inequality we are guaranteed that $t\geq\lfloor(d-1)/2\rfloor$. Since error correction will be more important than error detection in our applications, we denote the corresponding codes as $({\cal M},K,t)$-codes. For efficiency purposes, we will often want encoding and decoding to be polynomial-time.

For the Hamming metric over ${\cal F}^{n}$, we will sometimes call $k=\log_{|{\cal F}|}K$ the dimension of the code and denote the code itself as an $[n,k,d=2t+1]_{\cal F}$-code, following the standard notation in the literature. We will denote by $A_{|{\cal F}|}(n,d)$ the maximum $K$ possible in such a code (omitting the subscript when $|{\cal F}|=2$), and by $A(n,d,s)$ the maximum $K$ for such a code over $\{0,1\}^{n}$ with the additional restriction that all codewords have exactly $s$ ones.

If the code is linear (i.e., ${\cal F}$ is a field, ${\cal F}^{n}$ is a vector space over ${\cal F}$, and $C$ is a linear subspace), then one can fix a parity-check matrix $H$ as any matrix whose rows generate the orthogonal space $C^{\perp}$. Then for any $v\in{\cal F}^{n}$, the syndrome ${\mathsf{syn}}(v)\stackrel{{\scriptstyle\rm def}}{{=}}Hv$. The syndrome of a vector is its projection onto subspace that is orthogonal to the code and can thus be intuitively viewed as the vector modulo the code. Note that $v\in C\Leftrightarrow{\mathsf{syn}}(v)=0$. Note also that $H$ is an $(n-k)\times n$ matrix and that ${\mathsf{syn}}(v)$ is $n-k$ bits long.

The syndrome captures all the information necessary for decoding. That is, suppose a codeword $c$ is sent through a channel and the word $w=c+e$ is received. First, the syndrome of $w$ is the syndrome of $e$: ${\mathsf{syn}}(w)={\mathsf{syn}}(c)+{\mathsf{syn}}(e)=0+{\mathsf{syn}}(e)={\mathsf{syn}}(e)$. Moreover, for any value $u$, there is at most one word $e$ of weight less than $d/2$ such that ${\mathsf{syn}}(e)=u$ (because the existence of a pair of distinct words $e_{1},e_{2}$ would mean that $e_{1}-e_{2}$ is a codeword of weight less than $d$, but since $0^{n}$ is also a codeword and the minimum distance of the code is $d$, this is impossible). Thus, knowing syndrome ${\mathsf{syn}}(w)$ is enough to determine the error pattern $e$ if not too many errors occurred.

2.3 Min-Entropy, Statistical Distance, Universal Hashing, and Strong Extractors

When discussing security, one is often interested in the probability that the adversary predicts a random value (e.g., guesses a secret key). The adversary’s best strategy, of course, is to guess the most likely value. Thus, predictability of a random variable $A$ is $\max_{a}\Pr[A=a]$, and, correspondingly, min-entropy ${\mathbf{H}_{\infty}}(A)$ is $-\log(\max_{a}\Pr[A=a])$ (min-entropy can thus be viewed as the “worst-case” entropy [CG88]; see also Section 2.4).

The min-entropy of a distribution tells us how many nearly uniform random bits can be extracted from it. The notion of “nearly” is defined as follows. The statistical distance between two probability distributions $A$ and $B$ is $\mathbf{SD}\left({{A,B}}\right)=\frac{1}{2}\sum_{v}|\Pr(A=v)-\Pr(B=v)|$.

Recall the definition of strong randomness extractors [NZ96].

Definition 1.

Let $\mathsf{Ext}:\{0,1\}^{n}\to\{0,1\}^{\ell}$ be a polynomial time probabilistic function which uses $r$ bits of randomness. We say that $\mathsf{Ext}$ is an efficient $(n,m,\ell,\epsilon)$-strong extractor if for all min-entropy $m$ distributions $W$ on $\{0,1\}^{n}$, $\mathbf{SD}\left({{({\mathsf{Ext}(W;X),X}),({U_{\ell},X})}}\right)\leq\epsilon,$ where $X$ is uniform on $\{0,1\}^{r}$.

Strong extractors can extract at most $\ell=m-2\log\left({\frac{1}{\epsilon}}\right)+O(1)$ nearly random bits [RTS00]. Many constructions match this bound (see Shaltiel’s survey [Sha02] for references). Extractor constructions are often complex since they seek to minimize the length of the seed $X$. For our purposes, the length of $X$ will be less important, so universal hash functions  [CW79, WC81] (defined in the lemma below) will already give us the optimal $\ell=m-2\log\left({\frac{1}{\epsilon}}\right)+2$, as given by the leftover hash lemma below (see [HILL99, Lemma 4.8] as well as references therein for earlier versions):

Lemma 2.1 (Universal Hash Functions and the Leftover-Hash / Privacy-Amplification Lemma).

Assume a family of functions $\{H_{x}:\{0,1\}^{n}\to\{0,1\}^{\ell}\}_{x\in X}$ is universal: for all $a\neq b\in\{0,1\}^{n}$, $\Pr_{x\in X}[H_{x}(a)=H_{x}(b)]=2^{-\ell}$. Then, for any random variable $W$,

$$\mathbf{SD}\left({{({H_{X}(W),X})\ ,\ ({U_{\ell},X})}}\right)\leq\frac{1}{2}\sqrt{2^{-{\mathbf{H}_{\infty}}(W)}2^{\ell}}\,.$$ (1)

In particular, universal hash functions are $(n,m,\ell,\epsilon)$-strong extractors whenever $\ell\leq m-2\log\left({\frac{1}{\epsilon}}\right)+2$.

2.4 Average Min-Entropy

Recall that predictability of a random variable $A$ is $\max_{a}\Pr[A=a]$, and its min-entropy ${\mathbf{H}_{\infty}}(A)$ is $-\log(\max_{a}\Pr[A=a])$. Consider now a pair of (possibly correlated) random variables $A,B$. If the adversary finds out the value $b$ of $B$, then predictability of $A$ becomes $\max_{a}\Pr[A=a\mid B=b]$. On average, the adversary’s chance of success in predicting $A$ is then ${\mathbb{E}}_{{b\leftarrow{B}}}\left[{\max_{a}\Pr[A=a\mid B=b]}\right]$. Note that we are taking the average over $B$ (which is not under adversarial control), but the worst case over $A$ (because prediction of $A$ is adversarial once $b$ is known). Again, it is convenient to talk about security in log-scale, which is why we define the average min-entropy of $A$ given $B$ as simply the logarithm of the above:

$${\tilde{\mathbf{H}}_{\infty}}(A\mid B)\stackrel{{\scriptstyle\rm def}}{{=}}-\log\left({{\mathbb{E}}_{{b\leftarrow{B}}}\left[{\max_{a}\Pr[A=a\mid B=b]}\right]}\right)=-\log\left({{\mathbb{E}}_{{b\leftarrow{B}}}\left[{2^{-{\mathbf{H}_{\infty}}(A\mid B=b)}}\right]}\right)\,.$$

Because other notions of entropy have been studied in cryptographic literature, a few words are in order to explain why this definition is useful. Note the importance of taking the logarithm after taking the average (in contrast, for instance, to conditional Shannon entropy). One may think it more natural to define average min-entropy as ${\mathbb{E}}_{{b\leftarrow{B}}}\left[{{\mathbf{H}_{\infty}}(A\mid B=b)}\right]$, thus reversing the order of $\log$ and ${\mathbb{E}}$. However, this notion is unlikely to be useful in a security application. For a simple example, consider the case when $A$ and $B$ are 1000-bit strings distributed as follows: $B=U_{1000}$ and $A$ is equal to the value $b$ of $B$ if the first bit of $b$ is 0, and $U_{1000}$ (independent of $B$) otherwise. Then for half of the values of $b$, ${\mathbf{H}_{\infty}}(A\mid B=b)=0$, while for the other half, ${\mathbf{H}_{\infty}}(A\mid B=b)=1000$, so ${\mathbb{E}}_{{b\leftarrow B}}\left[{{\mathbf{H}_{\infty}}(A\mid B=b)}\right]=500$. However, it would be obviously incorrect to say that $A$ has 500 bits of security. In fact, an adversary who knows the value $b$ of $B$ has a slightly greater than $50\%$ chance of predicting the value of $A$ by outputting $b$. Our definition correctly captures this $50\%$ chance of prediction, because ${\tilde{\mathbf{H}}_{\infty}}(A\mid B)$ is slightly less than 1. In fact, our definition of average min-entropy is simply the logarithm of predictability.

The following useful properties of average min-entropy are proven in Appendix A. We also refer the reader to Appendix B for a generalization of average min-entropy and a discussion of the relationship between this notion and other notions of entropy.

Lemma 2.2.

Let $A,B,C$ be random variables. Then

• For any $\delta>0$, the conditional entropy ${\mathbf{H}_{\infty}}(A|B=b)$ is at least ${\tilde{\mathbf{H}}_{\infty}}(A|B)-\log(1/\delta)$ with probability at least $1-\delta$ over the choice of $b$.

• If $B$ has at most $2^{\lambda}$ possible values, then ${\tilde{\mathbf{H}}_{\infty}}(A\mid(B,C))\geq{\tilde{\mathbf{H}}_{\infty}}((A,B)\mid C)-{\lambda}\geq{\tilde{\mathbf{H}}_{\infty}}(A\mid C)-{\lambda}$. In particular, ${\tilde{\mathbf{H}}_{\infty}}(A\mid B)\geq{\mathbf{H}_{\infty}}((A,B))-{\lambda}\geq{\mathbf{H}_{\infty}}(A)-{\lambda}$.

2.5 Average-Case Extractors

Recall from Definition 1 that a strong extractor allows one to extract almost all the min-entropy from some nonuniform random variable $W$. In many situations, $W$ represents the adversary’s uncertainty about some secret $w$ conditioned on some side information $i$. Since this side information $i$ is often probabilistic, we shall find the following generalization of a strong extractor useful (see Lemma 4.1).

Definition 2.

Let $\mathsf{Ext}:\{0,1\}^{n}\to\{0,1\}^{\ell}$ be a polynomial time probabilistic function which uses $r$ bits of randomness. We say that $\mathsf{Ext}$ is an efficient average-case $(n,m,\ell,\epsilon)$-strong extractor if for all pairs of random variables $(W,I)$ such that $W$ is an $n$-bit string satisfying ${\tilde{\mathbf{H}}_{\infty}}(W\mid I)\geq m$, we have $\mathbf{SD}\left({{({\mathsf{Ext}(W;X),X,I}),({U_{\ell},X,I})}}\right)\leq\epsilon$, where $X$ is uniform on $\{0,1\}^{r}$.

To distinguish the strong extractors of Definition 1 from average-case strong extractors, we will sometimes call the former worst-case strong extractors. The two notions are closely related, as can be seen from the following simple application of Lemma 2.2(a).

Lemma 2.3.

For any $\delta>0$, if $\mathsf{Ext}$ is a (worst-case) $(n,m-\log\left({\frac{1}{\delta}}\right),\ell,\epsilon)$-strong extractor, then $\mathsf{Ext}$ is also an average-case $(n,m,\ell,\epsilon+\delta)$-strong extractor.

Proof.

Assume $(W,I)$ are such that ${\tilde{\mathbf{H}}_{\infty}}(W\mid I)\geq m$. Let $W_{i}=(W\mid I=i)$ and let us call the value $i$ “bad” if ${\mathbf{H}_{\infty}}(W_{i})<m-\log\left({\frac{1}{\delta}}\right)$. Otherwise, we say that $i$ is “good”. By Lemma 2.2(a), $\Pr(i\mbox{~{}is~{}bad})\leq\delta$. Also, for any good $i$, we have that $\mathsf{Ext}$ extracts $\ell$ bits that are $\epsilon$-close to uniform from $W_{i}$. Thus, by conditioning on the “goodness” of $I$, we get

$$\mathbf{SD}\left({{({\mathsf{Ext}(W;X),X,I}),({U_{\ell},X,I})}}\right) = \sum_{i}\Pr(i)\cdot\mathbf{SD}\left({{({\mathsf{Ext}(W_{i};X),X}),({U_{\ell},X})}}\right)$$

$$\leq \Pr(i\mbox{~{}is~{}bad})\cdot 1+\sum_{\mbox{\tiny{good}~{}}i}\Pr(i)\cdot\mathbf{SD}\left({{({\mathsf{Ext}(W_{i};X),X}),({U_{\ell},X})}}\right)$$

$$\leq \delta+\epsilon$$

∎

However, for many strong extractors we do not have to suffer this additional dependence on $\delta$, because the strong extractor may be already average-case. In particular, this holds for extractors obtained via universal hashing.

Lemma 2.4 (Generalized Leftover Hash Lemma).

Assume $\{H_{x}:\{0,1\}^{n}\to\{0,1\}^{\ell}\}_{x\in X}$ is a family of universal hash functions. Then, for any random variables $W$ and $I$,

$$\mathbf{SD}\left({{({H_{X}(W),X,I})\ ,\ ({U_{\ell},X,I})}}\right)\leq\frac{1}{2}\sqrt{2^{-{\tilde{\mathbf{H}}_{\infty}}(W\mid I)}2^{\ell}}\,.$$ (2)

In particular, universal hash functions are average-case $(n,m,\ell,\epsilon)$-strong extractors whenever $\ell\leq m-2\log\left({\frac{1}{\epsilon}}\right)+2$.

Proof.

Let $W_{i}=(W\mid I=i)$. Then

$$\mathbf{SD}\left({{({H_{X}(W),X,I})\ ,\ ({U_{\ell},X,I})}}\right) = {\mathbb{E}}_{{i}}\left[{\mathbf{SD}\left({{({H_{X}(W_{i}),X})\ ,\ ({U_{\ell},X})}}\right)}\right]$$

$$\leq \frac{1}{2}{\mathbb{E}}_{{i}}\left[{\sqrt{2^{-{\mathbf{H}_{\infty}}(W_{i})}2^{\ell}}}\right]$$

$$\leq \frac{1}{2}\sqrt{{\mathbb{E}}_{{i}}\left[{2^{-{\mathbf{H}_{\infty}}(W_{i})}2^{\ell}}\right]}$$

$$= \frac{1}{2}\sqrt{2^{-{\tilde{\mathbf{H}}_{\infty}}(W\mid I)}2^{\ell}}\,.$$

In the above derivation, the first inequality follows from the standard Leftover Hash Lemma (Lemma 2.1), and the second inequality follows from Jensen’s inequality (namely, ${\mathbb{E}}\left[{\sqrt{Z}}\right]\leq\sqrt{{\mathbb{E}}\left[{Z}\right]}$). ∎

3 New Definitions

3.1 Secure Sketches

Let ${\cal M}$ be a metric space with distance function ${\mathsf{dis}}$.

Definition 3.

An $({\cal M},m,{\tilde{m}},t)$-secure sketch is a pair of randomized procedures, “sketch” ($\mathsf{SS}$) and “recover” ($\mathsf{Rec}$), with the following properties:

1. The sketching procedure $\mathsf{SS}$ on input $w\in{\cal M}$ returns a bit string $s\in\{0,1\}^{*}$.

2. The recovery procedure $\mathsf{Rec}$ takes an element $w^{\prime}\in M$ and a bit string $s\in\{0,1\}^{*}$. The correctness property of secure sketches guarantees that if ${\mathsf{dis}(w,w^{\prime})}\leq t$, then $\mathsf{Rec}(w^{\prime},\mathsf{SS}(w))=w$. If ${\mathsf{dis}(w,w^{\prime})}>t$, then no guarantee is provided about the output of $\mathsf{Rec}$.

3. The security property guarantees that for any distribution $W$ over ${\cal M}$ with min-entropy $m$, the value of $W$ can be recovered by the adversary who observes $s$ with probability no greater than $2^{-{\tilde{m}}}$. That is, ${\tilde{\mathbf{H}}_{\infty}}(W\mid\mathsf{SS}(W))\geq{\tilde{m}}$.

A secure sketch is efficient if $\mathsf{SS}$ and $\mathsf{Rec}$ run in expected polynomial time.

Average-Case Secure Sketches.  In many situations, it may well be that the adversary’s information $i$ about the password $w$ is probabilistic, so that sometimes $i$ reveals a lot about $w$, but most of the time $w$ stays hard to predict even given $i$. In this case, the previous definition of secure sketch is hard to apply: it provides no guarantee if ${\mathbf{H}_{\infty}}(W|i)$ is not fixed to at least $m$ for some bad (but infrequent) values of $i$. A more robust definition would provide the same guarantee for all pairs of variables $(W,I)$ such that predicting the value of $W$ given the value of $I$ is hard. We therefore define an average-case secure sketch as follows:

Definition 4.

An average-case $({\cal M},m,{\tilde{m}},t)$-secure sketch is a secure sketch (as defined in Definition 3) whose security property is strengthened as follows: for any random variables $W$ over ${\cal M}$ and $I$ over $\{0,1\}^{*}$ such that ${\tilde{\mathbf{H}}_{\infty}}(W\mid I)\geq m$, we have ${\tilde{\mathbf{H}}_{\infty}}(W\mid(\mathsf{SS}(W),I))\geq{\tilde{m}}$. Note that an average-case secure sketch is also a secure sketch (take $I$ to be empty).

This definition has the advantage that it composes naturally, as shown in Lemma 4.7. All of our constructions will in fact be average-case secure sketches. However, we will often omit the term “average-case” for simplicity of exposition.

Entropy Loss.  The quantity ${\tilde{m}}$ is called the residual (min-)entropy of the secure sketch, and the quantity ${\lambda}=m-{\tilde{m}}$ is called the entropy loss of a secure sketch. In analyzing the security of our secure sketch constructions below, we will typically bound the entropy loss regardless of $m$, thus obtaining families of secure sketches that work for all $m$ (in general, [Rey07] shows that the entropy loss of a secure sketch is upperbounded by its entropy loss on the uniform distribution of inputs). Specifically, for a given construction of $\mathsf{SS}$, $\mathsf{Rec}$ and a given value $t$, we will get a value ${\lambda}$ for the entropy loss, such that, for any $m$, $(\mathsf{SS},\mathsf{Rec})$ is an $({\cal M},m,m-{\lambda},t)$-secure sketch. In fact, the most common way to obtain such secure sketches would be to bound the entropy loss by the length of the secure sketch $\mathsf{SS}(w)$, as given in the following simple lemma:

Lemma 3.1.

Assume some algorithms $\mathsf{SS}$ and $\mathsf{Rec}$ satisfy the correctness property of a secure sketch for some value of $t$, and that the output range of $\mathsf{SS}$ has size at most $2^{\lambda}$ (this holds, in particular, if the length of the sketch is bounded by ${\lambda}$). Then, for any min-entropy threshold $m$, $(\mathsf{SS},\mathsf{Rec})$ form an average-case $({\cal M},m,m-{\lambda},t)$-secure sketch for ${\cal M}$. In particular, for any $m$, the entropy loss of this construction is at most ${\lambda}$.

Proof.

The result follows immediately from Lemma 2.2(b), since $\mathsf{SS}(W)$ has at most $2^{\lambda}$ values: for any $(W,I)$, ${\tilde{\mathbf{H}}_{\infty}}(W\mid(\mathsf{SS}(W),I))\geq{\tilde{\mathbf{H}}_{\infty}}(W\mid I)-{\lambda}$. ∎

The above observation formalizes the intuition that a good secure sketch should be as short as possible. In particular, a short secure sketch will likely result in a better entropy loss. More discussion about this relation can be found in Section 9.

3.2 Fuzzy Extractors

Definition 5.

An $({\cal M},m,\ell,t,\epsilon)$-fuzzy extractor is a pair of randomized procedures, “generate” ($\mathsf{Gen}$) and “reproduce” ($\mathsf{Rep}$), with the following properties:

1. The generation procedure $\mathsf{Gen}$ on input $w\in{\cal M}$ outputs an extracted string $R\in\{0,1\}^{\ell}$ and a helper string $P\in\{0,1\}^{*}$.

2. The reproduction procedure $\mathsf{Rep}$ takes an element $w^{\prime}\in M$ and a bit string $P\in\{0,1\}^{*}$ as inputs. The correctness property of fuzzy extractors guarantees that if ${\mathsf{dis}(w,w^{\prime})}\leq t$ and $R,P$ were generated by $(R,P)\leftarrow\mathsf{Gen}(w)$, then $\mathsf{Rep}(w^{\prime},P)=R$. If ${\mathsf{dis}(w,w^{\prime})}>t$, then no guarantee is provided about the output of $\mathsf{Rep}$.

3. The security property guarantees that for any distribution $W$ on ${\cal M}$ of min-entropy $m$, the string $R$ is nearly uniform even for those who observe $P$: if $({R,P})\leftarrow\mathsf{Gen}(W)$, then $\mathbf{SD}\left({{({R,P}),\allowbreak({U_{\ell},P})}}\right)\allowbreak\leq\epsilon$.

A fuzzy extractor is efficient if $\mathsf{Gen}$ and $\mathsf{Rep}$ run in expected polynomial time.

In other words, fuzzy extractors allow one to extract some randomness $R$ from $w$ and then successfully reproduce $R$ from any string $w^{\prime}$ that is close to $w$. The reproduction uses the helper string $P$ produced during the initial extraction; yet $P$ need not remain secret, because $R$ looks truly random even given $P$. To justify our terminology, notice that strong extractors (as defined in Section 2) can indeed be seen as “nonfuzzy” analogs of fuzzy extractors, corresponding to $t=0$, $P=X$, and ${\cal M}=\{0,1\}^{n}$.

We reiterate that the nearly uniform random bits output by a fuzzy extractor can be used in any cryptographic context that requires uniform random bits (e.g., for secret keys). The slight nonuniformity of the bits may decrease security, but by no more than their distance $\epsilon$ from uniform. By choosing $\epsilon$ negligibly small (e.g., $2^{-80}$ should be enough in practice), one can make the decrease in security irrelevant.

Similarly to secure sketches, the quantity $m-\ell$ is called the entropy loss of a fuzzy extractor. Also similarly, a more robust definition is that of an average-case fuzzy extractor, which requires that if ${\tilde{\mathbf{H}}_{\infty}}(W\mid I)\geq m$, then $\mathbf{SD}\left({{({R,P,I}),({U_{\ell},P,I})}}\right)\leq\epsilon$ for any auxiliary random variable $I$.

4 Metric-Independent Results

In this section we demonstrate some general results that do not depend on specific metric spaces. They will be helpful in obtaining specific results for particular metric spaces below. In addition to the results in this section, some generic combinatorial lower bounds on secure sketches and fuzzy extractors are contained in Appendix C. We will later use these bounds to show the near-optimality of some of our constructions for the case of uniform inputs.

4.1 Construction of Fuzzy Extractors from Secure Sketches

Not surprisingly, secure sketches are quite useful in constructing fuzzy extractors. Specifically, we construct fuzzy extractors from secure sketches and strong extractors as follows: apply $\mathsf{SS}$ to $w$ to obtain $s$, and a strong extractor $\mathsf{Ext}$ with randomness $x$ to $w$ to obtain $R$. Store $(s,x)$ as the helper string $P$. To reproduce $R$ from $w^{\prime}$ and $P=(s,x)$, first use $\mathsf{Rec}(w^{\prime},s)$ to recover $w$ and then $\mathsf{Ext}(w,x)$ to get $R$.

A few details need to be filled in. First, in order to apply $\mathsf{Ext}$ to $w$, we will assume that one can represent elements of ${\cal M}$ using $n$ bits. Second, since after leaking the secure sketch value $s$, the password $w$ has only conditional min-entropy, technically we need to use the average-case strong extractor, as defined in Definition 2. The formal statement is given below.

Lemma 4.1 (Fuzzy Extractors from Sketches).

Assume $(\mathsf{SS},\mathsf{Rec})$ is an $({\cal M},m,\allowbreak{\tilde{m}},\allowbreak t)$-secure sketch, and let $\mathsf{Ext}$ be an average-case $(n,{\tilde{m}},\ell,\epsilon)$-strong extractor. Then the following $(\mathsf{Gen},\mathsf{Rep})$ is an $({\cal M},m,\ell,t,\epsilon)$-fuzzy extractor:

• $\mathsf{Gen}(w;r,x)$: set $P=({\mathsf{SS}(w;r),x})$, $R=\mathsf{Ext}(w;x)$, and output $({R,P})$.

• $\mathsf{Rep}(w^{\prime},({s,x}))$: recover $w=\mathsf{Rec}(w^{\prime},s)$ and output $R=\mathsf{Ext}(w;x)$.

Proof.

From the definition of secure sketch (Definition 3), we know that ${\tilde{\mathbf{H}}_{\infty}}(W\mid\mathsf{SS}(W))\geq{\tilde{m}}$. And since $\mathsf{Ext}$ is an average-case $(n,{\tilde{m}},\ell,\epsilon)$-strong extractor, $\mathbf{SD}\left({{(\mathsf{Ext}(W;X),\mathsf{SS}(W),X),(U_{\ell},\mathsf{SS}(W),X)}}\right)=\mathbf{SD}\left({{(R,P),(U_{\ell},P)}}\right)\leq\epsilon$. ∎

On the other hand, if one would like to use a worst-case strong extractor, we can apply Lemma 2.3 to get

Corollary 4.2.

If $(\mathsf{SS},\mathsf{Rec})$ is an $({\cal M},m,{\tilde{m}},t)$-secure sketch and $\mathsf{Ext}$ is an $(n,{\tilde{m}}-\log\left({\frac{1}{\delta}}\right),\ell,\epsilon)$-strong extractor, then the above construction $(\mathsf{Gen},\mathsf{Rep})$ is a $({\cal M},m,\ell,t,\epsilon+\delta)$-fuzzy extractor.

Both Lemma 4.1 and Corollary 4.2 hold (with the same proofs) for building average-case fuzzy extractors from average-case secure sketches.

While the above statements work for general extractors, for our purposes we can simply use universal hashing, since it is an average-case strong extractor that achieves the optimal [RTS00] entropy loss of $2\log\left({\frac{1}{\epsilon}}\right)$. In particular, using Lemma 2.4, we obtain our main corollary:

Lemma 4.3.

If $(\mathsf{SS},\mathsf{Rec})$ is an $({\cal M},m,{\tilde{m}},t)$-secure sketch and $\mathsf{Ext}$ is an $(n,{\tilde{m}},\ell,\allowbreak\epsilon)$-strong extractor given by universal hashing (in particular, any $\ell\leq{\tilde{m}}-2\log\left({\frac{1}{\epsilon}}\right)+2$ can be achieved), then the above construction $(\mathsf{Gen},\mathsf{Rep})$ is an $({\cal M},m,\ell,t,\epsilon)$-fuzzy extractor. In particular, one can extract up to $({\tilde{m}}-2\log\left({\frac{1}{\epsilon}}\right)+2)$ nearly uniform bits from a secure sketch with residual min-entropy ${\tilde{m}}$.

Again, if the above secure sketch is average-case secure, then so is the resulting fuzzy extractor. In fact, combining the above result with Lemma 3.1, we get the following general construction of average-case fuzzy extractors:

Lemma 4.4.

Assume some algorithms $\mathsf{SS}$ and $\mathsf{Rec}$ satisfy the correctness property of a secure sketch for some value of $t$, and that the output range of $\mathsf{SS}$ has size at most $2^{\lambda}$ (this holds, in particular, if the length of the sketch is bounded by ${\lambda}$). Then, for any min-entropy threshold $m$, there exists an average-case $({\cal M},m,m-{\lambda}-2\log\left({\frac{1}{\epsilon}}\right)+2,t,\epsilon)$-fuzzy extractor for ${\cal M}$. In particular, for any $m$, the entropy loss of the fuzzy extractor is at most ${\lambda}+2\log\left({\frac{1}{\epsilon}}\right)-2$.

4.2 Secure Sketches for Transitive Metric Spaces

We give a general technique for building secure sketches in transitive metric spaces, which we now define. A permutation $\pi$ on a metric space ${\cal M}$ is an isometry if it preserves distances, i.e., ${\mathsf{dis}(a,b)}={\mathsf{dis}(\pi(a),\pi(b))}$. A family of permutations $\Pi=\left\{{\pi_{i}}\right\}_{i\in{\cal I}}$ acts transitively on ${\cal M}$ if for any two elements $a,b\in{\cal M}$, there exists $\pi_{i}\in\Pi$ such that $\pi_{i}(a)=b$. Suppose we have a family $\Pi$ of transitive isometries for ${\cal M}$ (we will call such ${\cal M}$ transitive). For example, in the Hamming space, the set of all shifts $\pi_{x}(w)=w\oplus x$ is such a family (see Section 5 for more details on this example).

Construction 1 (Secure Sketch For Transitive Metric Spaces).

Let $C$ be an $({\cal M},K,t)$-code. Then the general sketching scheme $\mathsf{SS}$ is the following: given an input $w\in{\cal M}$, pick uniformly at random a codeword $b\in C$, pick uniformly at random a permutation $\pi\in\Pi$ such that $\pi(w)=b$, and output $\mathsf{SS}(w)=\pi$ (it is crucial that each $\pi\in\Pi$ should have a canonical description that is independent of how $\pi$ was chosen and, in particular, independent of $b$ and $w$; the number of possible outputs of $\mathsf{SS}$ should thus be $|\Pi|$). The recovery procedure $\mathsf{Rec}$ to find $w$ given $w^{\prime}$ and the sketch $\pi$ is as follows: find the closest codeword $b^{\prime}$ to $\pi(w^{\prime})$, and output $\pi^{-1}(b^{\prime})$.

Let $\Gamma$ be the number of elements $\pi\in\Pi$ such that $\min_{w,b}|\{\pi|\pi(w)=b\}|\geq\Gamma$. I.e., for each $w$ and $b$, there are at least $\Gamma$ choices for $\pi$. Then we obtain the following lemma.

Lemma 4.5.

$(\mathsf{SS},\mathsf{Rec})$ is an average-case $({\cal M},m,m-\log|\Pi|+\log\Gamma+\log K,t)$-secure sketch. It is efficient if operations on the code, as well as $\pi$ and $\pi^{-1}$, can be implemented efficiently.

Proof.

Correctness is clear: when ${\mathsf{dis}(w,w^{\prime})}\leq t$, then ${\mathsf{dis}(b,\pi(w^{\prime}))}\leq t$, so decoding $\pi(w^{\prime})$ will result in $b^{\prime}=b$, which in turn means that $\pi^{-1}(b^{\prime})=w$. The intuitive argument for security is as follows: we add $\log K+\log\Gamma$ bits of entropy by choosing $b$ and $\pi$, and subtract $\log|\Pi|$ by publishing $\pi$. Since given $\pi$, $w$ and $b$ determine each other, the total entropy loss is $\log|\Pi|-\log K-\log\Gamma$. More formally, ${\tilde{\mathbf{H}}_{\infty}}(W\mid\mathsf{SS}(W),I)={\tilde{\mathbf{H}}_{\infty}}((W,\mathsf{SS}(W))\mid I)-\log|\Pi|$ by Lemma 2.2(b). Given a particular value of $w$, there are $K$ equiprobable choices for $b$ and, further, at least $\Gamma$ equiprobable choices for $\pi$ once $b$ is picked, and hence any given permutation $\pi$ is chosen with probability at most $1/(K\Gamma)$ (because different choices for $b$ result in different choices for $\pi$). Therefore, for all $i$, $w$, and $\pi$, $\Pr[W=w\wedge\mathsf{SS}(w)=\pi\mid I=i]\leq\Pr[W=w\mid I=i]/(K\Gamma)$; hence ${\tilde{\mathbf{H}}_{\infty}}((W,\mathsf{SS}(W))\mid I)\geq{\tilde{\mathbf{H}}_{\infty}}(W\mid I)+\log K+\log\Gamma$. ∎

Naturally, security loss will be smaller if the code $C$ is denser.

We will discuss concrete instantiations of this approach in Section 5 and Section 6.1.

4.3 Changing Metric Spaces via Biometric Embeddings

We now introduce a general technique that allows one to build fuzzy extractors and secure sketches in some metric space ${\cal M}_{1}$ from fuzzy extractors and secure sketches in some other metric space ${\cal M}_{2}$. Below, we let ${\mathsf{dis}(\cdot,\cdot)}_{i}$ denote the distance function in ${\cal M}_{i}$. The technique is to embed ${\cal M}_{1}$ into ${\cal M}_{2}$ so as to “preserve” relevant parameters for fuzzy extraction.

Definition 6.

A function $f:{\cal M}_{1}\to{\cal M}_{2}$ is called a $(t_{1},t_{2},m_{1},m_{2})$-biometric embedding if the following two conditions hold:

• for any $w_{1},w_{1}^{\prime}\in{\cal M}_{1}$ such that ${\mathsf{dis}(w_{1},w_{1}^{\prime})}_{1}\leq t_{1}$, we have ${\mathsf{dis}(f(w_{1}),f(w_{2}))}_{2}\allowbreak\leq t_{2}$.

• for any distribution $W_{1}$ on ${\cal M}_{1}$ of min-entropy at least $m_{1}$, $f(W_{1})$ has min-entropy at least $m_{2}$.

The following lemma is immediate (correctness of the resulting fuzzy extractor follows from the first condition, and security follows from the second):

Lemma 4.6.

If $f$ is a $(t_{1},t_{2},m_{1},m_{2})$-biometric embedding of ${\cal M}_{1}$ into ${\cal M}_{2}$ and $(\mathsf{Gen}(\cdot),\mathsf{Rep}(\cdot,\cdot))$ is an $({\cal M}_{2},\allowbreak m_{2},\allowbreak\ell,\allowbreak t_{2},\allowbreak\epsilon)$-fuzzy extractor, then $(\mathsf{Gen}(f(\cdot)),\allowbreak\mathsf{Rep}(f(\cdot),\cdot))$ is an $({\cal M}_{1},\allowbreak m_{1},\allowbreak\ell,\allowbreak t_{1},\allowbreak\epsilon)$-fuzzy extractor.

It is easy to define average-case biometric embeddings (in which ${\tilde{\mathbf{H}}_{\infty}}(W_{1}\mid I)\geq m_{1}\Rightarrow{\tilde{\mathbf{H}}_{\infty}}(f(W_{1})\mid I)\geq m_{2}$), which would result in an analogous lemma for average-case fuzzy extractors.

For a similar result to hold for secure sketches, we need biometric embeddings with an additional property.

Definition 7.

A function $f:{\cal M}_{1}\to{\cal M}_{2}$ is called a $(t_{1},t_{2},{\lambda})$-biometric embedding with recovery information $g$ if:

• for any $w_{1},w_{1}^{\prime}\in{\cal M}_{1}$ such that ${\mathsf{dis}(w_{1},w_{1}^{\prime})}_{1}\leq t_{1}$, we have ${\mathsf{dis}(f(w_{1}),f(w_{2}))}_{2}\allowbreak\leq t_{2}$.

• $g:M_{1}\to\{0,1\}^{*}$ is a function with range size at most $2^{\lambda}$, and $w_{1}\in M_{1}$ is uniquely determined by $(f(w_{1}),g(w_{1}))$.

With this definition, we get the following analog of Lemma 4.6.

Lemma 4.7.

Let $f$ be a $(t_{1},t_{2},{\lambda})$ biometric embedding with recovery information $g$. Let $(\mathsf{SS},\mathsf{Rec})$ be an $({\cal M}_{2},\allowbreak m_{1}-{\lambda},\allowbreak{\tilde{m}}_{2},\allowbreak t_{2})$ average-case secure sketch. Let $\mathsf{SS}^{\prime}(w)=(\mathsf{SS}(f(w)),g(w))$. Let $\mathsf{Rec}^{\prime}(w^{\prime},(s,r))$ be the function obtained by computing $\mathsf{Rec}(w^{\prime},s)$ to get $f(w)$ and then inverting $(f(w),r)$ to get $w$. Then $(\mathsf{SS}^{\prime},\mathsf{Rec}^{\prime})$ is an $({\cal M}_{1},m_{1},{\tilde{m}}_{2},\allowbreak t_{1})$ average-case secure sketch.

Proof.

The correctness of this construction follows immediately from the two properties given in Definition 7. As for security, using Lemma 2.2(b) and the fact that the range of $g$ has size at most $2^{\lambda}$, we get that ${\tilde{\mathbf{H}}_{\infty}}(W\mid g(W))\geq m_{1}-{\lambda}$ whenever ${\mathbf{H}_{\infty}}(W)\geq m_{1}$. Moreover, since $W$ is uniquely recoverable from $f(W)$ and $g(W)$, it follows that ${\tilde{\mathbf{H}}_{\infty}}(f(W)\mid g(W))\geq m_{1}-{\lambda}$ as well, whenever ${\mathbf{H}_{\infty}}(W)\geq m_{1}$. Using the fact that $(\mathsf{SS},\mathsf{Rec})$ is an average-case $({\cal M}_{2},\allowbreak m_{1}-{\lambda},\allowbreak{\tilde{m}}_{2},\allowbreak t_{2})$ secure sketch, we get that ${\tilde{\mathbf{H}}_{\infty}}(f(W)\mid(\mathsf{SS}(W),g(W)))={\tilde{\mathbf{H}}_{\infty}}(f(W)\mid\mathsf{SS}^{\prime}(W))\geq{\tilde{m}}_{2}$. Finally, since the application of $f$ can only reduce min-entropy, ${\tilde{\mathbf{H}}_{\infty}}(W\mid\mathsf{SS}^{\prime}(W))\geq{\tilde{m}}_{2}$ whenever ${\mathbf{H}_{\infty}}(W)\geq m_{1}$. ∎

As we saw, the proof above critically used the notion of average-case secure sketches. Luckily, all our constructions (for example, those obtained via Lemma 3.1) are average-case, so this subtlety will not matter too much.

We will see the utility of this novel type of embedding in Section 7.

5 Constructions for Hamming Distance

In this section we consider constructions for the space ${\cal M}={\cal F}^{n}$ under the Hamming distance metric. Let $F=|{\cal F}|$ and $f=\log_{2}F$.

Secure Sketches: The Code-Offset Construction.  For the case of ${\cal F}=\{0,1\}$, Juels and Wattenberg [JW99] considered a notion of “fuzzy commitment.” Given an $[n,k,2t+1]_{2}$ error-correcting code $C$ (not necessarily linear), they fuzzy-commit to $x$ by publishing $w\oplus C(x)$. Their construction can be rephrased in our language to give a very simple construction of secure sketches for general ${\cal F}$.

We start with an $[n,k,2t+1]_{\cal F}$ error-correcting code $C$ (not necessarily linear). The idea is to use $C$ to correct errors in $w$ even though $w$ may not be in $C$. This is accomplished by shifting the code so that a codeword matches up with $w$, and storing the shift as the sketch. To do so, we need to view ${\cal F}$ as an additive cyclic group of order $F$ (in the case of most common error-correcting codes, ${\cal F}$ will anyway be a field).

Construction 2 (Code-Offset Construction).

On input $w$, select a random codeword $c$ (this is equivalent to choosing a random $x\in{\cal F}^{k}$ and computing $C(x)$), and set $\mathsf{SS}(w)$ to be the shift needed to get from $c$ to $w$: $\mathsf{SS}(w)=w-c$. Then $\mathsf{Rec}(w^{\prime},s)$ is computed by subtracting the shift $s$ from $w^{\prime}$ to get $c^{\prime}=w^{\prime}-s$; decoding $c^{\prime}$ to get $c$ (note that because ${\mathsf{dis}(w^{\prime},w)}\leq t$, so is ${\mathsf{dis}(c^{\prime},c)}$); and computing $w$ by shifting back to get $w=c+s$.

In the case of ${\cal F}=\{0,1\}$, addition and subtraction are the same, and we get that computation of the sketch is the same as the Juels-Wattenberg commitment: $\mathsf{SS}(w)=w\oplus C(x)$. In this case, to recover $w$ given $w^{\prime}$ and $s=\mathsf{SS}(w)$, compute $c^{\prime}=w^{\prime}\oplus s$, decode $c^{\prime}$ to get $c$, and compute $w=c\oplus s$.

When the code $C$ is linear, this scheme can be simplified as follows.

Construction 3 (Syndrome Construction).

Set $\mathsf{SS}(w)={\mathsf{syn}}(w)$. To compute $\mathsf{Rec}(w^{\prime},s)$, find the unique vector $e\in{\cal F}^{n}$ of Hamming weight $\leq t$ such that ${\mathsf{syn}}(e)={\mathsf{syn}}(w^{\prime})-s$, and output $w=w^{\prime}-e$.

As explained in Section 2, finding the short error-vector $e$ from its syndrome is the same as decoding the code. It is easy to see that two constructions above are equivalent: given ${\mathsf{syn}}(w)$ one can sample from $w-c$ by choosing a random string $v$ with ${\mathsf{syn}}(v)={\mathsf{syn}}(w)$; conversely, ${\mathsf{syn}}(w-c)={\mathsf{syn}}(w)$. To show that $\mathsf{Rec}$ finds the correct $w$, observe that ${\mathsf{dis}(w^{\prime}-e,w^{\prime})}\leq t$ by the constraint on the weight of $e$, and ${\mathsf{syn}}(w^{\prime}-e)={\mathsf{syn}}(w^{\prime})-{\mathsf{syn}}(e)={\mathsf{syn}}(w^{\prime})-({\mathsf{syn}}(w^{\prime})-s)=s$. There can be only one value within distance $t$ of $w^{\prime}$ whose syndrome is $s$ (else by subtracting two such values we get a codeword that is closer than $2t+1$ to 0, but 0 is also a codeword), so $w^{\prime}-e$ must be equal to $w$.

As mentioned in the introduction, the syndrome construction has appeared before as a component of some cryptographic protocols over quantum and other noisy channels [BBCS91, Cré97], though it has not been analyzed the same way.

Both schemes are $({\cal F}^{n},m,m-(n-k)f,t)$ secure sketches. For the randomized scheme, the intuition for understanding the entropy loss is as follows: we add $k$ random elements of ${\cal F}$ and publish $n$ elements of ${\cal F}$. The formal proof is simply Lemma 4.5, because addition in ${\cal F}^{n}$ is a family of transitive isometries. For the syndrome scheme, this follows from Lemma 3.1, because the syndrome is $(n-k)$ elements of ${\cal F}$.

We thus obtain the following theorem.

Theorem 5.1.

Given an $[n,k,2t+1]_{\cal F}$ error-correcting code, one can construct an average-case $({\cal F}^{n},m,\allowbreak m-(n-k)f,t)$ secure sketch, which is efficient if encoding and decoding are efficient. Furthermore, if the code is linear, then the sketch is deterministic and its output is $(n-k)$ symbols long.

In Appendix C we present some generic lower bounds on secure sketches and fuzzy extractors. Recall that $A_{F}(n,d)$ denotes the maximum number $K$ of codewords possible in a code of distance $d$ over $n$-character words from an alphabet of size $F$. Then by Lemma C.1, we obtain that the entropy loss of a secure sketch for the Hamming metric is at least $nf-\log_{2}A_{F}(n,2t+1)$ when the input is uniform (that is, when $m=nf$), because $K({\cal M},t)$ from Lemma C.1 is in this case equal to $A_{F}(n,2t+1)$ (since a code that corrects $t$ Hamming errors must have minimum distance at least $2t+1$). This means that if the underlying code is optimal (i.e., $K=A_{F}(n,2t+1)$), then the code-offset construction above is optimal for the case of uniform inputs, because its entropy loss is $nf-\log_{F}K\log_{2}F=nf-\log_{2}K$. Of course, we do not know the exact value of $A_{F}(n,d)$, let alone efficiently decodable codes which meet the bound, for many settings of $F$, $n$ and $d$. Nonetheless, the code-offset scheme gets as close to optimality as is possible from coding constraints. If better efficient codes are invented, then better (i.e., lower loss or higher error-tolerance) secure sketches will result.

Fuzzy Extractors.  As a warm-up, consider the case when $W$ is uniform ($m=n$) and look at the code-offset sketch construction: $v=w-C(x)$. For $\mathsf{Gen}(w)$, output $R=x$, $P=v$. For $\mathsf{Rep}(w^{\prime},P)$, decode $w^{\prime}-P$ to obtain $C(x)$ and apply $C^{-1}$ to obtain $x$. The result, quite clearly, is an $({\cal F}^{n},nf,kf,t,0)$-fuzzy extractor, since $v$ is truly random and independent of $x$ when $w$ is random. In fact, this is exactly the usage proposed by Juels and Wattenberg [JW99], except they viewed the above fuzzy extractor as a way to use $w$ to “fuzzy commit” to $x$, without revealing information about $x$.

Unfortunately, the above construction setting $R=x$ works only for uniform $W$, since otherwise $v$ would leak information about $x$.

In general, we use the construction in Lemma 4.3 combined with Theorem 5.1 to obtain the following theorem.

Theorem 5.2.

Given any $[n,k,2t+1]_{\cal F}$ code $C$ and any $m,\epsilon$, there exists an average-case $({\cal M},m,\ell,\allowbreak t,\epsilon)$-fuzzy extractor, where $\ell=m+kf-nf-2\log\left({\frac{1}{\epsilon}}\right)+2$. The generation $\mathsf{Gen}$ and recovery $\mathsf{Rep}$ are efficient if $C$ has efficient encoding and decoding.

6 Constructions for Set Difference

We now turn to inputs that are subsets of a universe ${\cal U}$; let $n=|{\cal U}|$. This corresponds to representing an object by a list of its features. Examples include “minutiae” (ridge meetings and endings) in a fingerprint, short strings which occur in a long document, or lists of favorite movies.

Recall that the distance between two sets $w,w^{\prime}$ is the size of their symmetric difference: ${\mathsf{dis}(w,w^{\prime})}=|w\triangle w^{\prime}|$. We will denote this metric space by ${\sf SDif}({\cal U})$. A set $w$ can be viewed as its characteristic vector in $\{0,1\}^{n}$, with $1$ at position $x\in{\cal U}$ if $x\in w$, and $0$ otherwise. Such representation of sets makes set difference the same as the Hamming metric. However, we will mostly focus on settings where $n$ is much larger than the size of $w$, so that representing a set $w$ by $n$ bits is much less efficient than, say, writing down a list of elements in $w$, which requires only $|w|\log n$ bits.

Large Versus Small Universes.  More specifically, we will distinguish two broad categories of settings. Let $s$ denote the size of the sets that are given as inputs to the secure sketch (or fuzzy extractor) algorithms. Most of this section studies situations where the universe size $n$ is superpolynomial in the set size $s$. We call this the “large universe” setting. In contrast, the “small universe” setting refers to situations in which $n=\mathit{poly}(s)$. We want our various constructions to run in polynomial time and use polynomial storage space. In the large universe setting, the $n$-bit string representation of a set becomes too large to be usable—we will strive for solutions that are polynomial in $s$ and $\log n$.

In fact, in many applications—for example, when the input is a list of book titles—it is possible that the actual universe is not only large, but also difficult to enumerate, making it difficult to even find the position in the characteristic vector corresponding to $x\in w$. In that case, it is natural to enlarge the universe to a well-understood class—for example, to include all possible strings of a certain length, whether or not they are actual book titles. This has the advantage that the position of $x$ in the characteristic vector is simply $x$ itself; however, because the universe is now even larger, the dependence of running time on $n$ becomes even more important.

Fixed versus Flexible Set Size.  In some situations, all objects are represented by feature sets of exactly the same size $s$, while in others the sets may be of arbitrary size. In particular, the original set $w$ and the corrupted set $w^{\prime}$ from which we would like to recover the original need not be of the same size. We refer to these two settings as fixed and flexible set size, respectively. When the set size is fixed, the distance ${\mathsf{dis}(w,w^{\prime})}$ is always even: ${\mathsf{dis}(w,w^{\prime})}=t$ if and only if $w$ and $w^{\prime}$ agree on exactly $s-\frac{t}{2}$ points. We will denote the restriction of ${\sf SDif}({\cal U})$ to $s$-element subsets by ${\sf SDif}_{s}({\cal U})$.

Summary.  As a point of reference, we will see below that $\log\binom{n}{s}-\log A(n,2t+1,s)$ is a lower bound on the entropy loss of any secure sketch for set difference (whether or not the set size is fixed). Recall that $A(n,2t+1,s)$ represents the size of the largest code for Hamming space with minimum distance $2t+1$, in which every word has weight exactly $s$. In the large universe setting, where $t\ll n$, the lower bound is approximately $t\log n$. The relevant lower bounds are discussed at the end of Sections 6.1 and 6.2.

In the following sections we will present several schemes which meet this lower bound. The setting of small universes is discussed in Section 6.1. We discuss the code-offset construction (from Section 5), as well as a permutation-based scheme which is tailored to fixed set size. The latter scheme is optimal for this metric, but impractical.

In the remainder of the section, we discuss schemes for the large universe setting. In Section 6.2 we give an improved version of the scheme of Juels and Sudan [JS06]. Our version achieves optimal entropy loss and storage $t\log n$ for fixed set size (notice the entropy loss doesn’t depend on the set size $s$, although the running time does). The new scheme provides an exponential improvement over the original parameters (which are analyzed in Appendix D). Finally, in Section 6.3 we describe how to adapt syndrome decoding algorithms for BCH codes to our application. The resulting scheme, called PinSketch, has optimal storage and entropy loss $t\log(n+1)$, handles flexible set sizes, and is probably the most practical of the schemes presented here. Another scheme achieving similar parameters (but less efficiently) can be adapted from information reconciliation literature [MTZ03]; see Section 9 for more details.

We do not discuss fuzzy extractors beyond mentioning here that each secure sketch presented in this section can be converted to a fuzzy extractor using Lemma 4.3. We have already seen an example of such conversion in Section 5.

Table 1 summarizes the constructions discussed in this section.

	Entropy Loss	Storage	Time	Set Size	Notes
Juels-Sudan	$t\log n+\log\left({\binom{n}{r}}/{\binom{n-s}{r-s}}\right)+2$	$r\log n$	$poly(r\log(n))$	Fixed	$r$ is a parameter
[JS06]					$s\leq r\leq n$
Generic	$n-\log A(n,2t+1)$	$n-\log A(n,2t+1)$	$poly(n)$	Flexible	ent. loss $\approx t\log(n)$
syndrome		(for linear codes)			when $t\ll n$
Permutation-	$\log\binom{n}{s}-\log A(n,2t+1,s)$	$O(n\log n)$	$poly(n)$	Fixed	ent. loss $\approx t\log n$
based					when $t\ll n$
Improved	$t\log n$	$t\log n$	$poly(s\log n)$	Fixed
JS
PinSketch	$t\log(n+1)$	$t\log(n+1)$	$poly(s\log n)$	Flexible	See Section 6.3
					for running time

Table 1: Summary of Secure Sketches for Set Difference.

6.1 Small Universes

When the universe size is polynomial in $s$, there are a number of natural constructions. The most direct one, given previous work, is the construction of Juels and Sudan [JS06]. Unfortunately, that scheme requires a fixed set size and achieves relatively poor parameters (see Appendix D).

We suggest two possible constructions. The first involves representing sets as $n$-bit strings and using the constructions of Section 5. The second construction, presented below, requires a fixed set size but achieves slightly improved parameters by going through “constant-weight” codes.

Permutation-based Sketch.  Recall the general construction of Section 4.2 for transitive metric spaces. Let $\Pi$ be a set of all permutations on ${\cal U}$. Given $\pi\in\Pi$, make it a permutation on ${\sf SDif}_{s}({\cal U})$ naturally: $\pi(w)=\{\pi(x)|x\in w\}$. This makes $\Pi$ into a family of transitive isometries on ${\sf SDif}_{s}({\cal U})$, and thus the results of Section 4.2 apply.

Let $C\subseteq\{0,1\}^{n}$ be any $[n,k,2t+1]$ binary code in which all words have weight exactly $s$. Such codes have been studied extensively (see, e.g., [AVZ00, BSSS90] for a summary of known upper and lower bounds). View elements of the code as sets of size $s$. We obtain the following scheme, which produces a sketch of length $O(n\log n)$.

Construction 4 (Permutation-Based Sketch).

On input $w\subseteq{\cal U}$ of size $s$, choose $b\subseteq{\cal U}$ at random from the code $C$, and choose a random permutation $\pi:{\cal U}\to{\cal U}$ such that $\pi(w)=b$ (that is, choose a random matching between $w$ and $b$ and a random matching between ${\cal U}-w$ and ${\cal U}-b$). Output $\mathsf{SS}(w)=\pi$ (say, by listing $\pi(1),\dots,\pi(n)$). To recover $w$ from $w^{\prime}$ such that ${\mathsf{dis}(w,w^{\prime})}\leq t$ and $\pi$, compute $b^{\prime}=\pi^{-1}(w^{\prime})$, decode the characteristic vector of $b^{\prime}$ to obtain $b$, and output $w=\pi(b)$.

This construction is efficient as long as decoding is efficient (everything else takes time $O(n\log n$)). By Lemma 4.5, its entropy loss is $\log{\binom{n}{s}}-k$: here $|\Pi|=n!$ and $\Gamma=s!(n-s)!$, so $\log|\Pi|-\log\Gamma=\log n!/(s!(n-s)!)$.

Comparing the Hamming Scheme with the Permutation Scheme.  The code-offset construction was shown to have entropy loss $n-\log A(n,2t+1)$ if an optimal code is used; the random permutation scheme has entropy loss $\log{\binom{n}{s}}-\log A(n,2t+1,s)$ for an optimal code. The Bassalygo-Elias inequality (see [vL92]) shows that the bound on the random permutation scheme is always at least as good as the bound on the code offset scheme: $A(n,d)\cdot 2^{-n}\leq A(n,d,s)\cdot{\binom{n}{s}}^{-1}$. This implies that $n-\log A(n,d)\geq\log{\binom{n}{s}}-\log A(n,d,s)$. Moreover, standard packing arguments give better constructions of constant-weight codes than they do of ordinary codes.  In fact, the random permutations scheme is optimal for this metric, just as the code-offset scheme is optimal for the Hamming metric.

We show this as follows. Restrict $t$ to be even, because ${\mathsf{dis}(w,w^{\prime})}$ is always even if $|w|=|w^{\prime}|$. Then the minimum distance of a code over ${\sf SDif}_{s}({\cal U})$ that corrects up to $t$ errors must be at least $2t+1$.Indeed, suppose not. Then take two codewords, $c_{1}$ and $c_{2}$ such that ${\mathsf{dis}(c_{1},c_{2})}\leq 2t$. There are $k$ elements in $c_{1}$ that are not in $c_{2}$ (call their set $c_{1}-c_{2}$) and $k$ elements in $c_{2}$ that are not in $c_{1}$ (call their set $c_{2}-c_{1}$), with $k\leq t$. Starting with $c_{1}$, remove $t/2$ elements of $c_{1}-c_{2}$ and add $t/2$ elements of $c_{2}-c_{1}$ to obtain a set $w$ (note that here we are using that $t$ is even; if $k<t/2$, then use $k$ elements). Then ${\mathsf{dis}(c_{1},w)}\leq t$ and ${\mathsf{dis}(c_{2},w)}\leq t$, and so if the received word is $w$, the receiver cannot be certain whether the sent word was $c_{1}$ or $c_{2}$ and hence cannot correct $t$ errors.

Therefore by Lemma C.1, we get that the entropy loss of a secure sketch must be at least $\log{\binom{n}{s}}-\log A(n,2t+1,s)$ in the case of a uniform input $w$. Thus in principle, it is better to use the random permutation scheme. Nonetheless, there are caveats. First, we do not know of explicitly constructed constant-weight codes that beat the Elias-Bassalygo inequality and would thus lead to better entropy loss for the random permutation scheme than for the Hamming scheme (see [BSSS90] for more on constructions of constant-weight codes and [AVZ00] for upper bounds). Second, much more is known about efficient implementation of decoding for ordinary codes than for constant-weight codes; for example, one can find off-the-shelf hardware and software for decoding many binary codes. In practice, the Hamming-based scheme is likely to be more useful.

6.2 Improving the Construction of Juels and Sudan

We now turn to the large universe setting, where $n$ is superpolynomial in the set size $s$, and we would like operations to be polynomial in $s$ and $\log n$.

Juels and Sudan [JS06] proposed a secure sketch for the set difference metric with fixed set size (called a “fuzzy vault” in that paper). We present their original scheme here with an analysis of the entropy loss in Appendix D. In particular, our analysis shows that the original scheme has good entropy loss only when the storage space is very large.

We suggest an improved version of the Juels-Sudan scheme which is simpler and achieves much better parameters. The entropy loss and storage space of the new scheme are both $t\log n$, which is optimal. (The same parameters are also achieved by the BCH-based construction PinSketch in Section 6.3.) Our scheme has the advantage of being even simpler to analyze, and the computations are simpler. As with the original Juels-Sudan scheme, we assume $n=|{\cal U}|$ is a prime power and work over ${\cal F}=\mathit{GF}(n)$.

An intuition for the scheme is that the numbers $y_{s+1},\dots,y_{r}$ from the JS scheme need not be chosen at random. One can instead evaluate them as $y_{i}=p^{\prime}(x_{i})$ for some polynomial $p^{\prime}$. One can then represent the entire list of pairs $(x_{i},y_{i})$ implicitly, using only a few of the coefficients of $p^{\prime}$. The new sketch is deterministic (this was not the case for our preliminary version in [DRS04]). Its implementation is available [HJR06].

Construction 5 (Improved JS Secure Sketch for Sets of Size $s$).

To compute $\mathsf{SS}(w)$:

• Let $p^{\prime}()$ be the unique monic polynomial of degree exactly $s$ such that $p^{\prime}(x)=0$ for all $x\in w$.
  (That is, let $p^{\prime}(z)\stackrel{{\scriptstyle\rm def}}{{=}}\prod_{x\in w}(z-x)$.)

• Output the coefficients of $p^{\prime}()$ of degree $s-1$ down to $s-t$.
  This is equivalent to computing and outputting the first $t$ symmetric polynomials of the values in $A$; i.e., if $w=\left\{{x_{1},\dots,x_{s}}\right\}$, then output

  $$\sum_{i}x_{i},\ \sum_{i\neq j}x_{i}x_{j},\ \ldots,\ \sum_{S\subseteq[s],|S|=t}\left({\prod_{i\in S}x_{i}}\right).$$

To compute $\mathsf{Rec}(w^{\prime},p^{\prime})$, where $w^{\prime}=\{a_{1},a_{2},\dots,a_{s}\}$,

• Create a new polynomial $p_{\mathrm{high}}$, of degree $s$ which shares the top $t+1$ coefficients of $p^{\prime}$; that is, let $p_{\mathrm{high}}(z)\stackrel{{\scriptstyle\rm def}}{{=}}z^{s}+\sum_{i=s-t}^{s-1}a_{i}z^{i}$.

• Evaluate $p_{\mathrm{high}}$ on all points in $w^{\prime}$ to obtain $s$ pairs $(a_{i},b_{i})$.

• Use $[s,s-t,t+1]_{\cal U}$ Reed-Solomon decoding (see, e.g., [Bla83, vL92]) to search for a polynomial $p_{\mathrm{low}}$ of degree $s-t-1$ such that $p_{\mathrm{low}}(a_{i})=b_{i}$ for at least $s-t/2$ of the $a_{i}$ values. If no such polynomial exists, then stop and output “fail.”

• Output the list of zeroes (roots) of the polynomial $p_{\mathrm{high}}-p_{\mathrm{low}}$ (see, e.g., [Sho05] for root-finding algorithms; they can be sped up by first factoring out the known roots—namely, $(z-a_{i})$ for the $s-t/2$ values of $a_{i}$ that were not deemed erroneous in the previous step).
  

To see that this secure sketch can tolerate $t$ set difference errors, suppose ${\mathsf{dis}(w,w^{\prime})}\leq t$. Let $p^{\prime}$ be as in the sketch algorithm; that is, $p^{\prime}(z)=\prod_{x\in w}(z-x)$. The polynomial $p^{\prime}$ is monic; that is, its leading term is $z^{s}$. We can divide the remaining coefficients into two groups: the high coefficients, denoted $a_{s-t},\dots,a_{s-1}$, and the low coefficients, denoted $b_{1},\dots,b_{s-t-1}$:

$$p^{\prime}(z)=\qquad\underbrace{z^{s}+\sum_{i=s-t}^{s-1}a_{i}z^{i}}_{p_{\mathrm{high}}(z)}\qquad+\qquad\underbrace{\sum_{i=0}^{s-t-1}b_{i}z^{i}}_{q(z)}\,.$$

We can write $p^{\prime}$ as $p_{\mathrm{high}}+q$, where $q$ has degree $s-t-1$. The recovery algorithm gets the coefficients of $p_{\mathrm{high}}$ as input. For any point $x$ in $w$, we have $0=p^{\prime}(x)=p_{\mathrm{high}}(x)+q(x)$. Thus, $p_{\mathrm{high}}$ and $-q$ agree at all points in $w$. Since the set $w$ intersects $w^{\prime}$ in at least $s-t/2$ points, the polynomial $-q$ satisfies the conditions of Step 3 in $\mathsf{Rec}$. That polynomial is unique, since no two distinct polynomials of degree $s-t-1$ can get the correct $b_{i}$ on more than $s-t/2$ $a_{i}$s (else, they agree on at least $s-t$ points, which is impossible). Therefore, the recovered polynomial $p_{\mathrm{low}}$ must be $-q$; hence $p_{\mathrm{high}}(x)-p_{\mathrm{low}}(x)=p^{\prime}(x)$. Thus, $\mathsf{Rec}$ computes the correct $p^{\prime}$ and therefore correctly finds the set $w$, which consists of the roots of $p^{\prime}$.

Since the output of $\mathsf{SS}$ is $t$ field elements, the entropy loss of the scheme is at most $t\log n$ by Lemma 3.1. (We will see below that this bound is tight, since any sketch must lose at least $t\log n$ in some situations.) We have proved:

Theorem 6.1 (Analysis of Improved JS).

Construction 5 is an average-case $({\sf SDif}_{s}({\cal U}),m,m-t\log n,t)$ secure sketch. The entropy loss and storage of the scheme are at most $t\log n$, and both the sketch generation $\mathsf{SS}()$ and the recovery procedure $\mathsf{Rec}()$ run in time polynomial in $s$, $t$ and $\log n$.

Lower Bounds for Fixed Set Size in a Large Universe.  The short length of the sketch makes this scheme feasible for essentially any ratio of set size to universe size (we only need $\log n$ to be polynomial in $s$). Moreover, for large universes the entropy loss $t\log n$ is essentially optimal for uniform inputs (i.e., when $m=\log{\binom{n}{s}}$). We show this as follows. As already mentioned in the Section 6.1, Lemma C.1 shows that for a uniformly distributed input, the best possible entropy loss is $m-m^{\prime}\geq\log{\binom{n}{s}}-\log A(n,2t+1,s)$.

By Theorem 12 of Agrell et al. [AVZ00], $A(n,2t+2,s)\leq\frac{\binom{n}{s-t}}{\binom{s}{{s-t}}}$. Noting that $A(n,2t+1,s)=A(n,2t+2,s)$ because distances in ${\sf SDif}_{s}({\cal U})$ are even, the entropy loss is at least

$$m-m^{\prime}\geq\log{\binom{n}{s}}-\log A(n,2t+1,s)\geq\log{\binom{n}{s}}-\log\left({{\binom{n}{s-t}}\Big{/}{\binom{s}{s-t}}}\right)=\log{\binom{n-s+t}{t}}\,.$$

When $n\gg s$, this last quantity is roughly $t\log n$, as desired.

6.3 Large Universes via the Hamming Metric: Sublinear-Time Decoding

In this section, we show that the syndrome construction of Section 5 can in fact be adapted for small sets in a large universe, using specific properties of algebraic codes. We will show that BCH codes, which contain Hamming and Reed-Solomon codes as special cases, have these properties. As opposed to the constructions of the previous section, the construction of this section is flexible and can accept input sets of any size.

Thus we obtain a sketch for sets of flexible size, with entropy loss and storage $t\log(n+1)$. We will assume that $n$ is one less than a power of 2: $n=2^{m}-1$ for some integer $m$, and will identify ${\cal U}$ with the nonzero elements of the binary finite field of degree $m$: ${\cal U}=\mathit{GF}(2^{m})^{*}$.

Syndrome Manipulation for Small-Weight Words.  Suppose now that we have a small set $w\subseteq{\cal U}$ of size $s$, where $n\gg s$. Let $x_{w}$ denote the characteristic vector of $w$ (see the beginning of Section 6). Then the syndrome construction says that $\mathsf{SS}(w)={\mathsf{syn}}(x_{w})$. This is an $(n-k)$-bit quantity. Note that the syndrome construction gives us no special advantage over the code-offset construction when the universe is small: storing the $n$-bit $x_{w}+C(r)$ for a random $k$-bit $r$ is not a problem. However, it’s a substantial improvement when $n\gg n-k$.

If we want to use ${\mathsf{syn}}(x_{w})$ as the sketch of $w$, then we must choose a code with $n-k$ very small. In particular, the entropy of $w$ is at most $\log{\binom{n}{s}}\approx s\log n$, and so the entropy loss $n-k$ had better be at most $s\log n$. Binary BCH codes are suitable for our purposes: they are a family of $[n,k,\delta]_{2}$ linear codes with $\delta=2t+1$ and $k=n-tm$ (assuming $n=2^{m}-1$) (see, e.g. [vL92]). These codes are optimal for $t\ll n$ by the Hamming bound, which implies that $k\leq n-\log{\binom{n}{t}}$ [vL92]. Using the syndrome sketch with a BCH code $C$, we get entropy loss $n-k=t\log(n+1)$, essentially the same as the $t\log n$ of the improved Juels-Sudan scheme (recall that $\delta\geq 2t+1$ allows us to correct $t$ set difference errors).

The only problem is that the scheme appears to require computation time $\Omega(n)$, since we must compute ${\mathsf{syn}}(x_{w})=Hx_{w}$ and, later, run a decoding algorithm to recover $x_{w}$. For BCH codes, this difficulty can be overcome. A word of small weight $w$ can be described by listing the positions on which it is nonzero. We call this description the support of $x_{w}$ and write ${\mathsf{supp}}(x_{w})$ (note that ${\mathsf{supp}}(x_{w})=w$; see the discussion of enlarging the universe appropriately at the beginning of Section 6).

The following lemma holds for general BCH codes (which include binary BCH codes and Reed-Solomon codes as special cases). We state it for binary codes since that is most relevant to the application:

Lemma 6.2.

For a $[n,k,\delta]$ binary BCH code $C$ one can compute:

• ${\mathsf{syn}}(x)$, given ${\mathsf{supp}}(x)$, in time polynomial in $\delta$, $\log n$, and $|{\mathsf{supp}}(x)|$

• ${\mathsf{supp}}(x)$, given ${\mathsf{syn}}(x)$ (when $x$ has weight at most $(\delta-1)/2$), in time polynomial in $\delta$ and $\log n$.

The proof of Lemma 6.2 requires a careful reworking of the standard BCH decoding algorithm. The details are presented in Appendix E. For now, we present the resulting secure sketch for set difference.

Construction 6 (PinSketch).

To compute $\mathsf{SS}(w)={\mathsf{syn}}(x_{w})$:

• Let $s_{i}=\sum_{x\in w}x^{i}$ (computations in $\mathit{GF}(2^{m})$).

• Output $\mathsf{SS}(w)=(s_{1},s_{3},s_{5},\dots,s_{2t-1})$.

To recover $\mathsf{Rec}(w^{\prime},(s_{1},s_{3},\dots,s_{2t-1}))$:

• Compute $(s^{\prime}_{1},s^{\prime}_{3},\dots,s^{\prime}_{2t-1})=\mathsf{SS}(w^{\prime})={\mathsf{syn}}(x_{w^{\prime}})$.

• Let $\sigma_{i}=s^{\prime}_{i}-s_{i}$ (in $\mathit{GF}(2^{m})$, so “$-$” is the same as “$+$”).

• Compute ${\mathsf{supp}}(v)$ such that ${\mathsf{syn}}(v)=(\sigma_{1},\sigma_{3},\dots,\sigma_{2t-1})$ and $|{\mathsf{supp}}(v)|\leq t$ by Lemma 6.2.

• If ${\mathsf{dis}(w,w^{\prime})}\leq t$, then ${\mathsf{supp}}(v)=w\triangle w^{\prime}$. Thus, output $w=w^{\prime}\triangle{\mathsf{supp}}(v)$.

An implementation of this construction, including the reworked BCH decoding algorithm, is available [HJR06].

The bound on entropy loss is easy to see: the output is $t\log(n+1)$ bits long, and hence the entropy loss is at most $t\log(n+1)$ by Lemma 3.1. We obtain:

Theorem 6.3.

PinSketch is an average-case $({\sf SDif}({\cal U}),m,m-t\log(n+1),t)$ secure sketch for set difference with storage $t\log(n+1)$. The algorithms $\mathsf{SS}$ and $\mathsf{Rec}$ both run in time polynomial in $t$ and $\log n$.

7 Constructions for Edit Distance

The space of interest in this section is the space ${\cal F}^{*}$ for some alphabet ${\cal F}$, with distance between two strings defined as the number of character insertions and deletions needed to get from one string to the other. Denote this space by ${\sf Edit}_{\cal F}(n)$. Let $F=|{\cal F}|$.

First, note that applying the generic approach for transitive metric spaces (as with the Hamming space and the set difference space for small universe sizes) does not work here, because the edit metric is not known to be transitive. Instead, we consider embeddings of the edit metric on $\{0,1\}^{n}$ into the Hamming or set difference metric of much larger dimension. We look at two types: standard low-distortion embeddings and “biometric” embeddings as defined in Section 4.3.

For the binary edit distance space of dimension $n$, we obtain secure sketches and fuzzy extractors correcting $t$ errors with entropy loss roughly $tn^{o(1)}$, using a standard embedding, and $2.38\sqrt[3]{tn\log n}$, using a relaxed embedding. The first technique works better when $t$ is small, say, $n^{1-\gamma}$ for a constant $\gamma>0$. The second technique is better when $t$ is large; it is meaningful roughly as long as $t<\frac{n}{15\log^{2}n}$.

7.1 Low-Distortion Embeddings

A (standard) embedding with distortion $D$ is an injection $\psi:{\cal M}_{1}\hookrightarrow{\cal M}_{2}$ such that for any two points $x,y\in{\cal M}_{1}$, the ratio $\frac{{\mathsf{dis}(\psi(x),\psi(y))}}{{\mathsf{dis}(x,y)}}$ is at least 1 and at most $D$.

When the preliminary version of this paper appeared [DRS04], no nontrivial embeddings were known mapping edit distance into $\ell_{1}$ or the Hamming metric (i.e., known embeddings had distortion $O(n)$). Recently, Ostrovsky and Rabani [OR05] gave an embedding of the edit metric over ${\cal F}=\{0,1\}$ into $\ell_{1}$ with subpolynomial distortion. It is an injective, polynomial-time computable embedding, which can be interpreted as mapping to the Hamming space $\{0,1\}^{d}$, where $d=\operatorname{poly}(n)$. 

Fact 7.1 ([OR05]).

There is a polynomial-time computable embedding $\psi_{\rm ed}:{\sf Edit}_{\{0,1\}}(n)\hookrightarrow\{0,1\}^{\operatorname{poly}(n)}$ with distortion $D_{\rm ed}(n)\stackrel{{\scriptstyle\rm def}}{{=}}2^{O(\sqrt{\log n\log\log n})}$.

We can compose this embedding with the fuzzy extractor constructions for the Hamming distance to obtain a fuzzy extractor for edit distance which will be good when $t$, the number of errors to be corrected, is quite small. Recall that instantiating the syndrome fuzzy extractor construction (Theorem 5.2) with a BCH code allows one to correct $t^{\prime}$ errors out of $d$ at the cost of $t^{\prime}\log d+2\log\left({\frac{1}{\epsilon}}\right)-2$ bits of entropy.

Construction 7.

For any length $n$ and error threshold $t$, let $\psi_{\rm ed}$ be the embedding given by Fact 7.1 from ${\sf Edit}_{\{0,1\}}(n)$ into $\{0,1\}^{d}$ (where $d=\operatorname{poly}(n)$), and let ${\mathsf{syn}}$ be the syndrome of a BCH code correcting $t^{\prime}=tD_{\rm ed}(n)$ errors in $\{0,1\}^{d}$. Let $\{H_{x}\}_{x\in X}$ be a family of universal hash functions from $\{0,1\}^{d}$ to $\{0,1\}^{\ell}$ for some $\ell$. To compute $\mathsf{Gen}$ on input $w\in{\sf Edit}_{\{0,1\}}(n)$, pick a random $x$ and output

$$R=H_{x}(\psi_{\rm ed}(w))\ ,P=({\mathsf{syn}}(\psi_{\rm ed}(w)),x)\,.$$

To compute $\mathsf{Rep}$ on inputs $w^{\prime}$ and $P=(s,x)$, compute $y=\mathsf{Rec}(\psi_{\rm ed}(w^{\prime}),s)$, where $\mathsf{Rec}$ is from Construction 3, and output $R=H_{x}(y)$.

Because $\psi_{\rm ed}$ is injective, a secure sketch can be constructed similarly: $\mathsf{SS}(w)={\mathsf{syn}}(\psi(w))$, and to recover $w$ from $w^{\prime}$ and $s$, compute $\psi_{\rm ed}^{-1}(\mathsf{Rec}(\psi_{\rm ed}(w^{\prime})))$. However, it is not known to be efficient, because it is not known how to compute $\psi^{-1}_{\rm ed}$ efficiently.

Proposition 7.2.

For any $n,t,m$, there is an average-case $({\sf Edit}_{\{0,1\}}(n),m,m^{\prime},\allowbreak t)$-secure sketch and an efficient average-case $({\sf Edit}_{\{0,1\}}(n),m,\ell,t,\epsilon)$-fuzzy extractor where $m^{\prime}=m-t2^{O(\sqrt{\log n\log\log n})}$ and $\ell=m^{\prime}-2\log\left({\frac{1}{\epsilon}}\right)+2$. In particular, for any $\alpha<1$, there exists an efficient fuzzy extractor tolerating $n^{\alpha}$ errors with entropy loss $n^{\alpha+o(1)}+2\log\left({\frac{1}{\epsilon}}\right)$.

Proof.

Construction 7 is the same as the construction of Theorem 5.2 (instantiated with a BCH-code-based syndrome construction) acting on $\psi_{\rm ed}(w)$. Because $\psi_{\rm ed}$ is injective, the min-entropy of $\psi_{\rm ed}(w)$ is the same as the min-entropy $m$ of $w$. The entropy loss in Construction 3 instantiated with BCH codes is $t^{\prime}\log d=t2^{O(\sqrt{\log n\log\log n})}\log\operatorname{poly}(n)$. Because $2^{O(\sqrt{\log n\log\log n})}$ grows faster than $\log n$, this is the same as $t2^{O(\sqrt{\log n\log\log n})}$. ∎

Note that the peculiar-looking distortion function from Fact 7.1 increases more slowly than any polynomial in $n$, but still faster than any polynomial in $\log n$. In sharp contrast, the best lower bound states that any embedding of ${\sf Edit}_{\{0,1\}}(n)$ into $\ell_{1}$ (and hence Hamming) must have distortion at least $\Omega(\log n/\log\log n)$ [AK07]. Closing the gap between the two bounds remains an open problem.

General Alphabets.  To extend the above construction to general ${\cal F}$, we represent each character of ${\cal F}$ as a string of $\log F$ bits. This is an embedding ${\cal F}^{n}$ into $\{0,1\}^{n\log F}$, which increases edit distance by a factor of at most $\log F$. Then $t^{\prime}=t(\log F)D_{\rm ed}(n)$ and $d=\operatorname{poly}(n,\log F)$. Using these quantities, we get the generalization of Proposition 7.2 for larger alphabets (again, by the same embedding) by changing the formula for $m^{\prime}$ to $m^{\prime}=m-t(\log F)2^{O(\sqrt{\log(n\log F)\log\log(n\log F)})}$.

7.2 Relaxed Embeddings for the Edit Metric

In this section, we show that a relaxed notion of embedding, called a biometric embedding in Section 4.3, can produce fuzzy extractors and secure sketches that are better than what one can get from the embedding of [OR05] when $t$ is large (they are also much simpler algorithmically, which makes them more practical). We first discuss fuzzy extractors and later extend the technique to secure sketches.

Fuzzy Extractors.  Recall that unlike low-distortion embeddings, biometric embeddings do not care about relative distances, as long as points that were “close” (closer than $t_{1}$) do not become “distant” (farther apart than $t_{2}$). The only additional requirement of a biometric embedding is that it preserve some min-entropy: we do not want too many points to collide together. We now describe such an embedding from the edit distance to the set difference.

A $c$-shingle is a length-$c$ consecutive substring of a given string $w$. A $c$-shingling [Bro97] of a string $w$ of length $n$ is the set (ignoring order or repetition) of all $(n-c+1)$ $c$-shingles of $w$. (For instance, a 3-shingling of “abcdecdeah” is {abc, bcd, cde, dec, ecd, dea, eah}.) Thus, the range of the $c$-shingling operation consists of all nonempty subsets of size at most $n-c+1$ of ${\cal F}^{c}$. Let ${\sf SDif}({\cal F}^{c})$ stand for the set difference metric over subsets of ${\cal F}^{c}$ and ${\sf SH}_{c}$ stand for the $c$-shingling map from ${\sf Edit}_{\cal F}(n)$ to ${\sf SDif}({\cal F}^{c})$. We now show that ${\sf SH}_{c}$ is a good biometric embedding.

Lemma 7.3.

For any $c$, ${\sf SH}_{c}$ is an average-case $(t_{1},t_{2}=(2c-1)t_{1},m_{1},m_{2}=m_{1}-\lceil\frac{n}{c}\rceil\log_{2}(n-c+1))$-biometric embedding of ${\sf Edit}_{\cal F}(n)$ into ${\sf SDif}({\cal F}^{c})$.

Proof.

Let $w,w^{\prime}\in{\sf Edit}_{\cal F}(n)$ be such that ${\mathsf{dis}(w,w^{\prime})}\leq t_{1}$ and $I$ be the sequence of at most $t_{1}$ insertions and deletions that transforms $w$ into $w^{\prime}$. It is easy to see that each character deletion or insertion adds at most $(2c-1)$ to the symmetric difference between ${\sf SH}_{c}(w)$ and ${\sf SH}_{c}(w^{\prime})$, which implies that ${\mathsf{dis}({\sf SH}_{c}(w),{\sf SH}_{c}(w^{\prime}))}\leq(2c-1)t_{1}$, as needed.

For $w\in{\cal F}^{n}$, define $g_{c}(w)$ as follows. Compute ${\sf SH}_{c}(w)$ and store the resulting shingles in lexicographic order $h_{1}\ldots h_{k}$ ($k\leq n-c+1$). Next, naturally partition $w$ into $\lceil n/c\rceil$ $c$-shingles $s_{1}\ldots s_{\lceil n/c\rceil}$, all disjoint except for (possibly) the last two, which overlap by $c\lceil n/c\rceil-n$ characters. Next, for $1\leq j\leq\lceil n/c\rceil$, set $p_{j}$ to be the index $i\in\left\{{0\ldots k}\right\}$ such that $s_{j}=h_{i}$. In other words, $p_{j}$ tells the index of the $j$th disjoint shingle of $w$ in the alphabetically ordered $k$-set ${\sf SH}_{c}(w)$. Set $g_{c}(w)=(p_{1},\dots,p_{\lceil n/c\rceil})$. (For instance, $g_{3}($“abcdecdeah”$)=(1,5,4,6)$, representing the alphabetical order of “abc”, “dec”, “dea” and “eah” in ${\sf SH}_{3}($“abcdecdeah”$)$.) The number of possible values for $g_{c}(w)$ is at most $(n-c+1)^{\lceil\frac{n}{c}\rceil}$, and $w$ can be completely recovered from ${\sf SH}_{c}(w)$ and $g_{c}(w)$.

Now, assume $W$ is any distribution of min-entropy at least $m_{1}$ on ${\sf Edit}_{\cal F}(n)$. Applying Lemma 2.2(b), we get ${\tilde{\mathbf{H}}_{\infty}}(W\mid g_{c}(W))\geq m_{1}\ -\lceil\frac{n}{c}\rceil\log_{2}(n-c+1)$. Since $\Pr(W=w\mid g_{c}(W)=g)=\Pr({\sf SH}_{c}(W)={\sf SH}_{c}(w)\mid g_{c}(W)=g)$ (because given $g_{c}(w)$, ${\sf SH}_{c}(w)$ uniquely determines $w$ and vice versa), by applying the definition of ${\tilde{\mathbf{H}}_{\infty}}$, we obtain ${\mathbf{H}_{\infty}}({\sf SH}_{c}(W))\geq{\tilde{\mathbf{H}}_{\infty}}({\sf SH}_{c}(W)\mid g_{c}(W))={\tilde{\mathbf{H}}_{\infty}}(W\mid g_{c}(W))$. The same proof holds for average min-entropy, conditioned on some auxiliary information $I$. ∎

By Theorem 6.3, for universe ${\cal F}^{c}$ of size $F^{c}$ and distance threshold $t_{2}=(2c-1)t_{1}$, we can construct a secure sketch for the set difference metric with entropy loss $t_{2}\lceil\log(F^{c}+1)\rceil$ ($\lceil\cdot\rceil$ because Theorem 6.3 requires the universe size to be one less than a power of 2). By Lemma 4.3, we can obtain a fuzzy extractor from such a sketch, with additional entropy loss $2\log\left({\frac{1}{\epsilon}}\right)-2$. Applying Lemma 4.6 to the above embedding and this fuzzy extractor, we obtain a fuzzy extractor for ${\sf Edit}_{\cal F}(n)$, any input entropy $m$, any distance $t$, and any security parameter $\epsilon$, with the following entropy loss:

$$\left\lceil\frac{n}{c}\right\rceil\cdot\log_{2}(n-c+1)+(2c-1)t\lceil\log(F^{c}+1)\rceil+2\log\left({\frac{1}{\epsilon}}\right)-2\,$$

(the first component of the entropy loss comes from the embedding, the second from the secure sketch for set difference, and the third from the extractor). The above sequence of lemmas results in the following construction, parameterized by shingle length $c$ and a family of universal hash functions ${\cal H}=\{{\sf SDif}({\cal F}^{c})\to\{0,1\}^{l}\}_{x\in X}$, where $l$ is equal to the input entropy $m$ minus the entropy loss above.

Construction 8 (Fuzzy Extractor for Edit Distance).

To compute $\mathsf{Gen}(w)$ for $|w|=n$:

• Compute ${\sf SH}_{c}(w)$ by computing $n-c+1$ shingles $(v_{1},v_{2},\dots,v_{n-c+1})$ and removing duplicates to form the shingle set $v$ from $w$.

• Compute $s={\mathsf{syn}}(x_{v})$ as in Construction 6.

• Select a hash function $H_{x}\in{\cal H}$ and output $(R=H_{x}(v),P=(s,x))$.

To compute $\mathsf{Rep}(w^{\prime},(s,x))$:

• Compute ${\sf SH}_{c}(w^{\prime})$ as above to get $v^{\prime}$.

• Use $\mathsf{Rec}(v^{\prime},s)$ from in Construction 6 to recover $v$.

• Output $R=H_{x}(v)$.

We thus obtain the following theorem.

Theorem 7.4.

For any $n,m,c$ and $0<\epsilon\leq 1$, there is an efficient average-case $({\sf Edit}_{\cal F}(n),m,m-\lceil\frac{n}{c}\rceil\log_{2}(n-c+1)-(2c-1)t\lceil\log(F^{c}+1)\rceil-2\log\left({\frac{1}{\epsilon}}\right)+2,t,\epsilon)$-fuzzy extractor.

Note that the choice of $c$ is a parameter; by ignoring $\lceil\cdot\rceil$ and replacing $n-c+1$ with $n$, $2c-1$ with $2c$ and $F^{c}+1$ with $F^{c}$, we get that the minimum entropy loss occurs near

$$c=\left(\frac{n\log n}{4t\log F}\right)^{1/3}$$

and is about $2.38\left(t\log F\right)^{1/3}\left(n\log n\right)^{2/3}$ ($2.38$ is really $\sqrt[3]{4}+1/\sqrt[3]{2}$). In particular, if the original string has a linear amount of entropy $\theta(n\log F)$, then we can tolerate $t=\Omega(n\log^{2}F/\log^{2}n)$ insertions and deletions while extracting $\theta(n\log F)-2\log\left({\frac{1}{\epsilon}}\right)$ bits. The number of bits extracted is linear; if the string length $n$ is polynomial in the alphabet size $F$, then the number of errors tolerated is linear also.

Secure Sketches.  Observe that the proof of Lemma 7.3 actually demonstrates that our biometric embedding based on shingling is an embedding with recovery information $g_{c}$. Observe also that it is easy to reconstruct $w$ from ${\sf SH}_{c}(w)$ and $g_{c}(w)$. Finally, note that PinSketch (Construction 6) is an average-case secure sketch (as are all secure sketches in this work). Thus, combining Theorem 6.3 with Lemma 4.7, we obtain the following theorem.

Construction 9 (Secure Sketch for Edit Distance).

For $\mathsf{SS}(w)$, compute $v={\sf SH}_{c}(w)$ and $s_{1}={\mathsf{syn}}(x_{v})$ as in Construction 8. Compute $s_{2}=g_{c}(w)$, writing each $p_{j}$ as a string of $\lceil\log n\rceil$ bits. Output $s=(s_{1},s_{2})$. For $\mathsf{Rec}(w^{\prime},(s_{1},s_{2}))$, recover $v$ as in Construction 8, sort it in alphabetical order, and recover $w$ by stringing along elements of $v$ according to indices in $s_{2}$.

Theorem 7.5.

For any $n,m,c$ and $0<\epsilon\leq 1$, there is an efficient average-case $({\sf Edit}_{\cal F}(n),m,m-\lceil\frac{n}{c}\rceil\log_{2}(n-c+1)-(2c-1)t\lceil\log(F^{c}+1)\rceil,t)$ secure sketch.

The discussion about optimal values of $c$ from above applies equally here.

Remark 1.

In our definitions of secure sketches and fuzzy extractors, we required the original $w$ and the (potentially) modified $w^{\prime}$ to come from the same space ${\cal M}$. This requirement was for simplicity of exposition. We can allow $w^{\prime}$ to come from a larger set, as long as distance from $w$ is well-defined. In the case of edit distance, for instance, $w^{\prime}$ can be shorter or longer than $w$; all the above results will apply as long as it is still within $t$ insertions and deletions.

8 Probabilistic Notions of Correctness

The error model considered so far in this work is very strong: we required that secure sketches and fuzzy extractors accept every secret $w^{\prime}$ within distance $t$ of the original input $w$, with no probability of error.

Such a stringent model is useful as it makes no assumptions on either the exact stochastic properties of the error process or the adversary’s computational limits. However, Lemma C.1 shows that secure sketches (and fuzzy extractors) correcting $t$ errors can only be as “good” as error-correcting codes with minimum distance $2t+1$. By slightly relaxing the correctness condition, we will see that one can tolerate many more errors. For example, there is no good code which can correct $n/4$ errors in the binary Hamming metric: by the Plotkin bound (see, e.g., [Sud01, Lecture 8]) a code with minimum distance greater than $n/2$ has at most $2n$ codewords. Thus, there is no secure sketch with residual entropy $m^{\prime}\geq\log n$ which can correct $n/4$ errors with probability 1. However, with the relaxed notions of correctness below, one can tolerate arbitrarily close to $n/2$ errors, i.e., correct $n(\frac{1}{2}-\gamma)$ errors for any constant $\gamma>0$, and still have residual entropy $\Omega(n)$.

In this section, we discuss three relaxed error models and show how the constructions of the previous sections can be modified to gain greater error-correction in these models. We will focus on secure sketches for the binary Hamming metric. The same constructions yield fuzzy extractors (by Lemma 4.1). Many of the observations here also apply to metrics other than Hamming.

A common point is that we will require only that the a corrupted input $w^{\prime}$ be recovered with probability at least $1-\alpha<1$ (the probability space varies). We describe each model in terms of the additional assumptions made on the error process. We describe constructions for each model in the subsequent sections.

Random Errors.

Assume there is a known distribution on the errors which occur in the data. For the Hamming metric, the most common distribution is the binary symmetric channel $BSC_{p}$: each bit of the input is flipped with probability $p$ and left untouched with probability $1-p$. We require that for any input $w$, $\mathsf{Rec}(W^{\prime},\mathsf{SS}(w))=w$ with probability at least $1-\alpha$ over the coins of $\mathsf{SS}$ and over $W^{\prime}$ drawn applying the noise distribution to $w$.

In that case, one can correct an error rate up to Shannon’s bound on noisy channel coding. This bound is tight. Unfortunately, the assumption of a known noise process is too strong for most applications: there is no reason to believe we understand the exact distribution on errors which occur in complex data such as biometrics. However, it provides a useful baseline by which to measure results for other models.

Input-dependent Errors.

The errors are adversarial, subject only to the conditions that (a) the error magnitude ${\mathsf{dis}(w,w^{\prime})}$ is bounded to a maximum of $t$, and (b) the corrupted word depends only on the input $w$, and not on the secure sketch $\mathsf{SS}(w)$. Here we require that for any pair $w,w^{\prime}$ at distance at most $t$, we have $\mathsf{Rec}(w^{\prime},\mathsf{SS}(w))=w$ with probability at least $1-\alpha$ over the coins of $\mathsf{SS}$.

This model encompasses any complex noise process which has been observed to never introduce more than $t$ errors. Unlike the assumption of a particular distribution on the noise, the bound on magnitude can be checked experimentally. Perhaps surprisingly, in this model we can tolerate just as large an error rate as in the model of random errors. That is, we can tolerate an error rate up to Shannon’s coding bound and no more.

Computationally bounded Errors.

The errors are adversarial and may depend on both $w$ and the publicly stored information $\mathsf{SS}(w)$. However, we assume that the errors are introduced by a process of bounded computational power. That is, there is a probabilistic circuit of polynomial size (in the length $n$) which computes $w^{\prime}$ from $w$. The adversary cannot, for example, forge a digital signature and base the error pattern on the signature.

It is not clear whether this model allows correcting errors up to the Shannon bound, as in the two models above. The question is related to open questions on the construction of efficiently list-decodable codes. However, when the error rate is either very high or very low, then the appropriate list-decodable codes exist and we can indeed match the Shannon bound.

Analogues for Noisy Channels and the Hamming Metric.  Models analogous to the ones above have been studied in the literature on codes for noisy binary channels (with the Hamming metric). Random errors and computationally bounded errors both make obvious sense in the coding context [Sha48, MPSW05]. The second model — input-dependent errors — does not immediately make sense in a coding situation, since there is no data other than the transmitted codeword on which errors could depend. Nonetheless, there is a natural, analogous model for noisy channels: one can allow the sender and receiver to share either (1) common, secret random coins (see [DGL04, Lan04] and references therein) or (2) a side channel with which they can communicate a small number of noise-free, secret bits [Gur03].

Existing results on these three models for the Hamming metric can be transported to our context using the code-offset construction:

$$\mathsf{SS}(w;x)=w\oplus C(x)\,.$$

Roughly, any code which corrects errors in the models above will lead to a secure sketch (resp. fuzzy extractor) which corrects errors in the model. We explore the consequences for each of the three models in the next sections.

8.1 Random Errors

The random error model was famously considered by Shannon [Sha48]. He showed that for any discrete, memoryless channel, the rate at which information can be reliably transmitted is characterized by the maximum mutual information between the inputs and outputs of the channel. For the binary symmetric channel with crossover probability $p$, this means that there exist codes encoding $k$ bits into $n$ bits, tolerating error probability $p$ in each bit if and only if

$$\frac{k}{n}<1-h(p)-\delta(n)\,,$$

where $h(p)=-p\log p-(1-p)\log(1-p)$ and $\delta(n)=o(1)$. Computationally efficient codes achieving this bound were found later, most notably by Forney [For66]. We can use the code-offset construction $\mathsf{SS}(w;x)=w\oplus C(x)$ with an appropriate concatenated code [For66] or, equivalently, $\mathsf{SS}(w)={\mathsf{syn}}_{C}(w)$ since the codes can be linear. We obtain:

Proposition 8.1.

For any error rate $0<p<1/2$ and constant $\delta>0$, for large enough $n$ there exist secure sketches with entropy loss $(h(p)+\delta)n$, which correct the error rate of $p$ in the data with high probability (roughly $2^{-c_{\delta}n}$ for a constant $c_{\delta}>0$).

The probability here is taken over the errors only (the distribution on input strings $w$ can be arbitrary).

The quantity $h(p)$ is less than 1 for any $p$ in the range $(0,1/2)$. In particular, one can get nontrivial secure sketches even for a very high error rate $p$ as long as it is less than $1/2$; in contrast, no secure sketch which corrects errors with probability 1 can tolerate $t\geq n/4$. Note that several other works on biometric cryptosystems consider the model of randomized errors and obtain similar results, though the analyses assume that the distribution on inputs is uniform [TG04, CZ04].

A Matching Impossibility Result.  The bound above is tight. The matching impossibility result also applies to input-dependent and computationally bounded errors, since random errors are a special case of both more complex models.

We start with an intuitive argument: If a secure sketch allows recovering from random errors with high probability, then it must contain enough information about $w$ to describe the error pattern (since given $w^{\prime}$ and $\mathsf{SS}(w)$, one can recover the error pattern with high probability). Describing the outcome of $n$ independent coin flips with probability $p$ of heads requires $nh(p)$ bits, and so the sketch must reveal $nh(p)$ bits about $w$.

In fact, that argument simply shows that $nh(p)$ bits of Shannon information are leaked about $w$, whereas we are concerned with min-entropy loss as defined in Section 3. To make the argument more formal, let $W$ be uniform over $\{0,1\}^{n}$ and observe that with high probability over the output of the sketching algorithm, $v=\mathsf{SS}(w)$, the conditional distribution $W_{v}=W|_{\mathsf{SS}(W)=v}$ forms a good code for the binary symmetric channel. That is, for most values $v$, if we sample a random string $w$ from $W|_{\mathsf{SS}(W)=v}$ and send it through a binary symmetric channel, we will be able to recover the correct value $w$. That means there exists some $v$ such that both (a) $W_{v}$ is a good code and (b) ${\mathbf{H}_{\infty}}(W_{v})$ is close to ${\tilde{\mathbf{H}}_{\infty}}(W|\mathsf{SS}(W))$. Shannon’s noisy coding theorem says that such a code can have entropy at most $n(1-h(p)+o(1))$. Thus the construction above is optimal:

Proposition 8.2.

For any error rate $0<p<1/2$, any secure sketch $\mathsf{SS}$ which corrects random errors (with rate $p$) with probability at least $2/3$ has entropy loss at least $n(h(p)-o(1))$; that is, ${\tilde{\mathbf{H}}_{\infty}}(W|\mathsf{SS}(W))\leq n(1-h(p)-o(1))$ when $W$ is drawn uniformly from $\{0,1\}^{n}$.

8.2 Randomizing Input-dependent Errors

Assuming errors distributed randomly according to a known distribution seems very limiting. In the Hamming metric, one can construct a secure sketch which achieves the same result as with random errors for every error process where the magnitude of the error is bounded, as long as the errors are independent of the output of $\mathsf{SS}(W)$. The same technique was used previously by Bennett et al. [BBR88, p. 216] and, in a slightly different context, Lipton [Lip94, DGL04].

The idea is to choose a random permutation $\pi:[n]\to[n]$, permute the bits of $w$ before applying the sketch, and store the permutation $\pi$ along with $\mathsf{SS}(\pi(w))$. Specifically, let $C$ be a linear code tolerating a $p$ fraction of random errors with redundancy $n-k\approx nh(p)$. Let

$$\mathsf{SS}(w;\pi)=(\pi,\ {\mathsf{syn}}_{C}(\pi(w)))\,,$$

where $\pi:[n]\to[n]$ is a random permutation and, for $w=w_{1}\cdots w_{n}\in\{0,1\}^{n}$, $\pi(w)$ denotes the permuted string $w_{\pi(1)}w_{\pi(2)}\cdots w_{\pi(n)}$. The recovery algorithm operates in the obvious way: it first permutes the input $w^{\prime}$ according to $\pi$ and then runs the usual syndrome recovery algorithm to recover $\pi(w)$.

For any particular pair $w,w^{\prime}$, the difference $w\oplus w^{\prime}$ will be mapped to a random vector of the same weight by $\pi$, and any code for the binary symmetric channel (with rate $p\approx t/n$) will correct such an error with high probability.

Thus we can construct a sketch with entropy loss $n(h(t/n)-o(1))$ which corrects any $t$ flipped bits with high probability. This is optimal by the lower bound for random errors (Proposition 8.2), since a sketch for data-dependent errors will also correct random errors. It is also possible to reduce the amount of randomness, so that the size of the sketch meets the same optimal bound [Smi07].

An alternative approach to input-dependent errors is discussed in the last paragraph of Section 8.3.

8.3 Handling Computationally Bounded Errors Via List Decoding

As mentioned above, many results on noisy coding for other error models in Hamming space extend to secure sketches. The previous sections discussed random, and randomized, errors. In this section, we discuss constructions [Gur03, Lan04, MPSW05] which transform a list-decodable code, defined below, into uniquely decodable codes for a particular error model. These transformations can also be used in the setting of secure sketches, leading to better tolerance of computationally bounded errors. For some ranges of parameters, this yields optimal sketches, that is, sketches which meet the Shannon bound on the fraction of tolerated errors.

List-Decodable Codes.  A code $C$ in a metric space ${\cal M}$ is called list-decodable with list size $L$ and distance $t$ if for every point $x\in{\cal M}$, there are at most $L$ codewords within distance $t$ of ${\cal M}$. A list-decoding algorithm takes as input a word $x$ and returns the corresponding list $c_{1},c_{2},\dots$ of codewords. The most interesting setting is when $L$ is a small polynomial (in the description size $\log|{\cal M}|$), and there exists an efficient list-decoding algorithm. It is then feasible for an algorithm to go over each word in the list and accept if it has some desirable property. There are many examples of such codes for the Hamming space; for a survey see Guruswami’s thesis [Gur01]. Recently there has been significant progress in constructing list-decodable codes for large alphabets, e.g., [PV05, GR06].

Similarly, we can define a list-decodable secure sketch with size $L$ and distance $t$ as follows: for any pair of words $w,w^{\prime}\in{\cal M}$ at distance at most $t$, the algorithm $\mathsf{Rec}(w^{\prime},\mathsf{SS}(w))$ returns a list of at most $L$ points in ${\cal M}$; if ${\mathsf{dis}}(w,w^{\prime})\leq t$, then one of the words in the list must be $w$ itself. The simplest way to obtain a list-decodable secure sketch is to use the code-offset construction of Section 5 with a list-decodable code for the Hamming space. One obtains a different example by running the improved Juels-Sudan scheme for set difference (Construction 5), replacing ordinary decoding of Reed-Solomon codes with list decoding. This yields a significant improvement in the number of errors tolerated at the price of returning a list of possible candidates for the original secret.

Sieving the List.  Given a list-decodable secure sketch $\mathsf{SS}$, all that’s needed is to store some additional information which allows the receiver to disambiguate $w$ from the list. Let’s suggestively name the additional information $Tag(w;R)$, where $R$ is some additional randomness (perhaps a key). Given a list-decodable code $C$, the sketch will typically look like

$$\mathsf{SS}(w;x)=(\ w\oplus C(x),\ Tag(w)\ )\,.$$

On inputs $w^{\prime}$ and $(\Delta,tag)$, the recovery algorithm consists of running the list-decoding algorithm on $w^{\prime}\oplus\Delta$ to obtain a list of possible codewords $C(x_{1}),\dots,C(x_{L})$. There is a corresponding list of candidate inputs $w_{1},\dots,w_{L}$, where $w_{i}=C(x_{i})\oplus\Delta$, and the algorithm outputs the first $w_{i}$ in the list such that $Tag(w_{i})=tag$. We will choose the function $Tag()$ so that the adversary can not arrange to have two values in the list with valid tags.

We consider two $Tag()$ functions, inspired by [Gur03, Lan04, MPSW05].

1. Recall that for computationally bounded errors, the corrupted string $w^{\prime}$ depends on both $w$ and $\mathsf{SS}(w)$, but $w^{\prime}$ is computed by a probabilistic circuit of size polynomial in $n$.

   Consider $Tag(w)=\mathsf{hash}(w)$, where $\mathsf{hash}$ is drawn from a collision-resistant function family. More specifically, we will use some extra randomness $r$ to choose a key $\mathit{key}$ for a collision-resistant hash family. The output of the sketch is then

   $$\mathsf{SS}(w;x,r)=(\ w\oplus C(x),\ \mathit{key}(r),\ \mathsf{hash}_{\mathit{key}(r)}(w)\ ).$$

   If the list-decoding algorithm for the code $C$ runs in polynomial time, then the adversary succeeds only if he can find a value $w_{i}\neq w$ such that $\mathsf{hash}_{\mathit{key}}(w_{i})=\mathsf{hash}_{\mathit{key}}(w)$, that is, only by finding a collision for the hash function. By assumption, a polynomially bounded adversary succeeds only with negligible probability.

   The additional entropy loss, beyond that of the code-offset part of the sketch, is bounded above by the output length of the hash function. If $\alpha$ is the desired bound on the adversary’s success probability, then for standard assumptions on hash functions this loss will be polynomial in $\log(1/\alpha)$.

   In principle this transformation can yield sketches which achieve the optimal entropy loss $n(h(t/n)-o(1))$, since codes with polynomial list size $L$ are known to exist for error rates approaching the Shannon bound. However, in order to use the construction the code must also be equipped with a reasonably efficient algorithm for finding such a list. This is necessary both so that recovery will be efficient and, more subtly, for the proof of security to go through (that way we can assume that the polynomial-time adversary knows the list of words generated during the recovery procedure). We do not know of efficient (i.e., polynomial-time constructible and decodable) binary list-decodable codes which meet the Shannon bound for all choices of parameters. However, when the error rate is near $\frac{1}{2}$ such codes are known [GS00]. Thus, this type of construction yields essentially optimal sketches when the error rate is near $1/2$. This is quite similar to analogous results on channel coding [MPSW05]. Relatively little is known about the performance of efficiently list-decodable codes in other parameter ranges for binary alphabets [Gur01].

2. A similar, even simpler, transformation can be used in the setting of input-dependent errors (i.e., when the errors depend only on the input and not on the sketch, but the adversary is not assumed to be computationally bounded). One can store $Tag(w)=(I,h_{I}(w))$, where $\left\{{h_{i}}\right\}_{i\in{\cal I}}$ comes from a universal hash family mapping from ${\cal M}$ to $\{0,1\}^{\ell}$, where $\ell=\log\left({\frac{1}{\alpha}}\right)+\log L$ and $\alpha$ is the probability of an incorrect decoding.

   The proof is simple: the values $w_{1},\dots,w_{L}$ do not depend on $I$, and so for any value $w_{i}\neq w$, the probability that $h_{I}(w_{i})=h_{I}(w)$ is $2^{-\ell}$. There are at most $L$ possible candidates, and so the probability that any one of the elements in the list is accepted is at most $L\cdot 2^{-\ell}=\alpha$ The additional entropy loss incurred is at most $\ell=\log\left({\frac{1}{\alpha}}\right)+\log(L)$.

   In principle, this transformation can do as well as the randomization approach of the previous section. However, we do not know of efficient binary list-decodable codes meeting the Shannon bound for most parameter ranges. Thus, in general, randomizing the errors (as in the previous section) works better in the input-dependent setting.

9 Secure Sketches and Efficient Information Reconciliation

Suppose Alice holds a set $w$ and Bob holds a set $w^{\prime}$ that are close to each other. They wish to reconcile the sets: to discover the symmetric difference $w\triangle w^{\prime}$ so that they can take whatever appropriate (application-dependent) action to make their two sets agree. Moreover, they wish to do this communication-efficiently, without having to transmit entire sets to each other. This problem is known as set reconciliation and naturally arises in various settings.

Let $(\mathsf{SS},\mathsf{Rec})$ be a secure sketch for set difference that can handle distance up to $t$; furthermore, suppose that $|w\triangle w^{\prime}|\leq t$. Then if Bob receives $s=\mathsf{SS}(w)$ from Alice, he will be able to recover $w$, and therefore $w\triangle w^{\prime}$, from $s$ and $w^{\prime}$. Similarly, Alice will be able find $w\triangle w^{\prime}$ upon receiving $s^{\prime}=\mathsf{SS}(w^{\prime})$ from Bob. This will be communication-efficient if $|s|$ is small. Note that our secure sketches for set difference of Sections 6.2 and  6.3 are indeed short—in fact, they are secure precisely because they are short. Thus, they also make good set reconciliation schemes.

Conversely, a good (single-message) set reconciliation scheme makes a good secure sketch: simply make the message the sketch. The entropy loss will be at most the length of the message, which is short in a communication-efficient scheme. Thus, the set reconciliation scheme CPISync of [MTZ03] makes a good secure sketch. In fact, it is quite similar to the secure sketch of Section 6.2, except instead of the top $t$ coefficients of the characteristic polynomial it uses the values of the polynomial at $t$ points.

PinSketch of Section 6.3, when used for set reconciliation, achieves the same parameters as CPISync of [MTZ03], except decoding is faster, because instead of spending $t^{3}$ time to solve a system of linear equations, it spends $t^{2}$ time for Euclid’s algorithm. Thus, it can be substituted wherever CPISync is used, such as PDA synchronization [STA03] and PGP key server updates [Min04]. Furthermore, optimizations that improve computational complexity of CPISync through the use of interaction [MT02] can also be applied to PinSketch.

Of course, secure sketches for other metrics are similarly related to information reconciliation for those metrics. In particular, ideas for edit distance very similar to ours were independently considered in the context of information reconciliation by [CT04].

Appendix A Proof of Lemma 2.2

Recall that Lemma 2.2 considered random variables $A,B,C$ and consisted of two parts, which we prove one after the other.

Part (a) stated that for any $\delta>0$, the conditional entropy ${\mathbf{H}_{\infty}}(A|B=b)$ is at least ${\tilde{\mathbf{H}}_{\infty}}(A|B)-\log(1/\delta)$ with probability at least $1-\delta$ (the probability here is taken over the choice of $b$). Let $p=2^{-{\tilde{\mathbf{H}}_{\infty}}(A\mid B)}={\mathbb{E}}_{{b}}\left[{2^{-{\mathbf{H}_{\infty}}(A\mid B=b)}}\right]$. By the Markov inequality, $2^{-{\mathbf{H}_{\infty}}(A\mid B=b)}\leq p/\delta$ with probability at least $1-\delta$. Taking logarithms, part (a) follows.

Part (b) stated that if $B$ has at most $2^{\lambda}$ possible values, then ${\tilde{\mathbf{H}}_{\infty}}(A\mid(B,C))\geq{\tilde{\mathbf{H}}_{\infty}}((A,B)\mid C)-{\lambda}\geq{\tilde{\mathbf{H}}_{\infty}}(A\mid C)-{\lambda}$. In particular, ${\tilde{\mathbf{H}}_{\infty}}(A\mid B)\geq{\mathbf{H}_{\infty}}((A,B))-{\lambda}\geq{\mathbf{H}_{\infty}}(A)-{\lambda}$. Clearly, it suffices to prove the first assertion (the second follows from taking $C$ to be constant). Moreover, the second inequality of the first assertion follows from the fact that $\Pr[A=a\wedge B=b\mid C=c]\leq\Pr[A=a\mid C=c]$, for any $c$. Thus, we prove only that ${\tilde{\mathbf{H}}_{\infty}}(A\mid(B,C))\geq{\tilde{\mathbf{H}}_{\infty}}((A,B)\mid C)-{\lambda}$:

$${\tilde{\mathbf{H}}_{\infty}}(A\mid(B,C)) = -\log{\mathbb{E}}_{{(b,c)\leftarrow(B,C)}}\left[{\max_{a}\Pr[A=a\mid B=b\wedge C=c]}\right]$$

$$= -\log\sum_{(b,c)}\max_{a}\Pr[A=a\mid B=b\wedge C=c]\Pr[B=b\wedge C=c]$$

$$= -\log\sum_{(b,c)}\max_{a}\Pr[A=a\wedge B=b\mid C=c]\Pr[C=c]$$

$$= -\log\sum_{b}{\mathbb{E}}_{{c\leftarrow C}}\left[{\max_{a}\Pr[A=a\wedge B=b\mid C=c]}\right]$$

$$\geq -\log\sum_{b}{\mathbb{E}}_{{c\leftarrow C}}\left[{\max_{a,b^{\prime}}\Pr[A=a\wedge B=b^{\prime}\mid C=c]}\right]$$

$$= -\log\sum_{b}2^{-{\tilde{\mathbf{H}}_{\infty}}((A,B)\mid C)}\geq-\log 2^{\lambda}2^{-{\tilde{\mathbf{H}}_{\infty}}((A,B)\mid C)}={\tilde{\mathbf{H}}_{\infty}}((A,B)\mid C)-{\lambda}\,.$$

The first inequality in the above derivation holds since taking the maximum over all pairs $(a,b^{\prime})$ (instead of over pairs $(a,b)$ where $b$ is fixed) increases the terms of the sum and hence decreases the negative log of the sum.

Appendix B On Smooth Variants of Average Min-Entropy and the Relationship to Smooth Rényi Entropy

Min-entropy is a rather fragile measure: a single high-probability element can ruin the min-entropy of an otherwise good distribution. This is often circumvented within proofs by considering a distribution which is close to the distribution of interest, but which has higher entropy. Renner and Wolf [RW04] systematized this approach with the notion of $\epsilon$-smooth min-entropy (they use the term “Rényi entropy of order $\infty$” instead of “min-entropy”), which considers all distributions that are $\epsilon$-close:

$${\mathbf{H}_{\infty}^{\epsilon}}(A)=\max_{B:\ \mathbf{SD}\left({{A,B}}\right)\leq\epsilon}{\mathbf{H}_{\infty}}(B)\,.$$

Smooth min-entropy very closely relates to the amount of extractable nearly uniform randomness: if one can map $A$ to a distribution that is $\epsilon$-close to $U_{m}$, then ${\mathbf{H}_{\infty}^{\epsilon}}(A)\geq m$; conversely, from any $A$ such that ${\mathbf{H}_{\infty}^{\epsilon}}(A)\geq m$, and for any $\epsilon_{2}$, one can extract $m-2\log\left({\frac{1}{\epsilon_{2}}}\right)$ bits that are $\epsilon+\epsilon_{2}$-close to uniform (see [RW04] for a more precise statement; the proof of the first statement follows by considering the inverse map, and the proof of the second from the leftover hash lemma, which is discussed in more detail in Lemma 2.4). For some distributions, considering the smooth min-entropy will improve the number and quality of extractable random bits.

A smooth version of average min-entropy can also be considered, defined as

$${\tilde{\mathbf{H}}_{\infty}^{\epsilon}}(A\mid B)=\allowbreak\max_{(C,D):\ \mathbf{SD}\left({{(A,B),(C,D)}}\right)\leq\epsilon}{\tilde{\mathbf{H}}_{\infty}}(C\mid D)\,.$$

It similarly relates very closely to the number of extractable bits that look nearly uniform to the adversary who knows the value of $B$, and is therefore perhaps a better measure for the quality of a secure sketch that is used to obtain a fuzzy extractor. All our results can be cast in terms of smooth entropies throughout, with appropriate modifications (if input entropy is $\epsilon$-smooth, then output entropy will also be $\epsilon$-smooth, and extracted random strings will be $\epsilon$ further away from uniform). We avoid doing so for simplicity of exposition. However, for some input distributions, particularly ones with few elements of relatively high probability, this will improve the result by giving more secure sketches or longer-output fuzzy extractors.

Finally, a word is in order on the relation of average min-entropy to conditional min-entropy, introduced by Renner and Wolf in [RW05], and defined as ${\mathbf{H}_{\infty}}(A\mid B)=-\log\max_{a,b}\Pr(A=a\mid B=b)=\min_{b}{\mathbf{H}_{\infty}}(A\mid B=b)$ (an $\epsilon$-smooth version is defined analogously by considering all distributions $(C,D)$ that are within $\epsilon$ of $(A,B)$ and taking the maximum among them). This definition is too strict: it takes the worst-case $b$, while for randomness extraction (and many other settings, such as predictability by an adversary), average-case $b$ suffices. Average min-entropy leads to more extractable bits. Nevertheless, after smoothing the two notions are equivalent up to an additive $\log\left({\frac{1}{\epsilon}}\right)$ term: ${\tilde{\mathbf{H}}_{\infty}^{\epsilon}}(A\mid B)\geq{\mathbf{H}_{\infty}^{\epsilon}}(A\mid B)$ and ${\mathbf{H}_{\infty}}^{\epsilon+\epsilon_{2}}(A\mid B)\geq{\tilde{\mathbf{H}}_{\infty}^{\epsilon}}(A\mid B)-\log\left({\frac{1}{\epsilon_{2}}}\right)$ (for the case of $\epsilon=0$, this follows by constructing a new distribution that eliminates all $b$ for which ${\mathbf{H}_{\infty}}(A\mid B=b)<{\tilde{\mathbf{H}}_{\infty}}(A\mid B)-\log\left({\frac{1}{\epsilon_{2}}}\right)$, which will be within $\epsilon_{2}$ of the $(A,B)$ by Markov’s inequality; for $\epsilon>0$, an analogous proof works). Note that by Lemma 2.2(b), this implies a simple chain rule for ${\mathbf{H}_{\infty}^{\epsilon}}$ (a more general one is given in [RW05, Section 2.4]): ${\mathbf{H}_{\infty}}^{\epsilon+\epsilon_{2}}(A\mid B)\geq{\tilde{\mathbf{H}}_{\infty}^{\epsilon}}((A,B))-H_{0}(B)-\log\left({\frac{1}{\epsilon_{2}}}\right)$, where $H_{0}(B)$ is the logarithm of the number of possible values of $B$.

Appendix C Lower Bounds from Coding

Recall that an $({\cal M},K,t)$ code is a subset of the metric space ${\cal M}$ which can correct $t$ errors (this is slightly different from the usual notation of coding theory literature).

Let $K({\cal M},t)$ be the largest $K$ for which there exists an $({\cal M},K,t)$-code. Given any set $S$ of $2^{m}$ points in ${\cal M}$, we let $K({\cal M},t,S)$ be the largest $K$ such that there exists an $({\cal M},K,t)$-code all of whose $K$ points belong to $S$. Finally, we let $L({\cal M},t,m)=\log(\min_{|S|=2^{m}}K(n,t,S))$. Of course, when $m=\log|{\cal M}|$, we get $L({\cal M},t,n)=\allowbreak\log K({\cal M},t)$. The exact determination of quantities $K({\cal M},t)$ and $K({\cal M},t,S)$ is a central problem of coding theory and is typically very hard. To the best of our knowledge, the quantity $L({\cal M},t,m)$ was not explicitly studied in any of three metrics that we study, and its exact determination seems hard as well.

We give two simple lower bounds on the entropy loss (one for secure sketches, the other for fuzzy extractors) which show that our constructions for the Hamming and set difference metrics output as much entropy $m^{\prime}$ as possible when the original input distribution is uniform. In particular, because the constructions have the same entropy loss regardless of $m$, they are optimal in terms of the entropy loss $m-m^{\prime}$. We conjecture that the constructions also have the highest possible value $m^{\prime}$ for all values of $m$, but we do not have a good enough understanding of $L({\cal M},t,m)$ (where ${\cal M}$ is the Hamming metric) to substantiate the conjecture.

Lemma C.1.

The existence of an $({\cal M},m,m^{\prime},t)$ secure sketch implies that $m^{\prime}\leq L({\cal M},t,m)$. In particular, when $m=\log|{\cal M}|$ (i.e., when the password is truly uniform), $m^{\prime}\leq\log K({\cal M},t)$.

Proof.

Assume $\mathsf{SS}$ is such a secure sketch. Let $S$ be any set of size $2^{m}$ in ${\cal M}$, and let $W$ be uniform over $S$. Then we must have ${\tilde{\mathbf{H}}_{\infty}}(W\mid\mathsf{SS}(W))\geq m^{\prime}$. In particular, there must be some value $v$ such that ${\mathbf{H}_{\infty}}(W\mid\mathsf{SS}(W)=v)\geq m^{\prime}$. But this means that conditioned on $\mathsf{SS}(W)=v$, there are at least $2^{m^{\prime}}$ points $w$ in $S$ (call this set $T$) which could produce $\mathsf{SS}(W)=v$. We claim that these $2^{m^{\prime}}$ values of $w$ form a code of error-correcting distance $t$. Indeed, otherwise there would be a point $w^{\prime}\in{\cal M}$ such that ${\mathsf{dis}(w_{0},w^{\prime})}\leq t$ and ${\mathsf{dis}(w_{1},w^{\prime})}\leq t$ for some $w_{0},w_{1}\in T$. But then we must have that $\mathsf{Rec}(w^{\prime},v)$ is equal to both $w_{0}$ and $w_{1}$, which is impossible. Thus, the set $T$ above must form an $({\cal M},2^{m^{\prime}},t)$-code inside $S$, which means that $m^{\prime}\leq\log K({\cal M},t,S)$. Since $S$ was arbitrary, the bound follows. ∎

Lemma C.2.

The existence of $({\cal M},m,\ell,t,\epsilon)$-fuzzy extractors implies that $\ell\leq L({\cal M},t,m)-\log(1-\epsilon)$. In particular, when $m=\log|{\cal M}|$ (i.e., when the password is truly uniform), $\ell\leq\log K({\cal M},t)-\log(1-\epsilon)$.

Proof.

Assume $(\mathsf{Gen},\mathsf{Rep})$ is such a fuzzy extractor. Let $S$ be any set of size $2^{m}$ in ${\cal M}$, let $W$ be uniform over $S$ and let $(R,P)\leftarrow\mathsf{Gen}(W)$. Then we must have $\mathbf{SD}\left({{({R,P}),({U_{\ell},P})}}\right)\leq\epsilon$. In particular, there must be some value $p$ of $P$ such that $R$ is $\epsilon$-close to $U_{\ell}$ conditioned on $P=p$. In particular, this means that conditioned on $P=p$, there are at least $(1-\epsilon)2^{\ell}$ points $r\in\{0,1\}^{\ell}$ (call this set $T$) which could be extracted with $P=p$. Now, map every $r\in T$ to some arbitrary $w\in S$ which could have produced $r$ with nonzero probability given $P=p$, and call this map $C$. $C$ must define a code with error-correcting distance $t$ by the same reasoning as in Lemma C.1. ∎

Observe that, as long as $\epsilon<1/2$, we have $0<-\log(1-\epsilon)<1$, so the lower bounds on secure sketches and fuzzy extractors differ by less than a bit.

Appendix D Analysis of the Original Juels-Sudan Construction

In this section we present a new analysis for the Juels-Sudan secure sketch for set difference. We will assume that $n=|{\cal U}|$ is a prime power and work over the field ${\cal F}=\mathit{GF}(n)$. On input set $w$, the original Juels-Sudan sketch is a list of $r$ pairs of points $(x_{i},y_{i})$ in ${\cal F}$, for some parameter $r$, $s<r\leq n$. It is computed as follows:

Construction 10 (Original Juels-Sudan Secure Sketch [JS06]).

Input: a set $w\subseteq{\cal F}$ of size $s$ and parameters $r\in\left\{{s+1,\dots,n}\right\},t\in\left\{{1,\dots,s}\right\}$

• Choose $p()$ at random from the set of polynomials of degree at most $k=s-t-1$ over ${\cal F}$.
  Write $w=\left\{{x_{1},\dots,x_{s}}\right\}$, and let $y_{i}=p(x_{i})$ for $i=1,\dots,s$.

• Choose $r-s$ distinct points $x_{s+1},\dots,x_{r}$ at random from ${\cal F}-w$.

• For $i=s+1,\dots,r$, choose $y_{i}\in{\cal F}$ at random such that $y_{i}\neq p(x_{i})$.

• Output $\mathsf{SS}(w)=\left\{{(x_{1},y_{1}),\dots,(x_{r},y_{r})}\right\}$ (in lexicographic order of $x_{i}$).

The parameter $t$ measures the error-tolerance of the scheme: given $\mathsf{SS}(w)$ and a set $w^{\prime}$ such that $w\triangle w^{\prime}\leq t$, one can recover $w$ by considering the pairs $(x_{i},y_{i})$ for $x_{i}\in w^{\prime}$ and running Reed-Solomon decoding to recover the low-degree polynomial $p(\cdot)$. When the parameter $r$ is very small, the scheme corrects approximately twice as many errors with good probability (in the “input-dependent” sense from Section 8). When $r$ is low, however, we show here that the bound on the entropy loss becomes very weak.

The parameter $r$ dictates the amount of storage necessary, one on hand, and also the security of the scheme (that is, for $r=s$ the scheme leaks all information and for larger and larger $r$ there is less information about $w$). Juels and Sudan actually propose two analyses for the scheme. First, they analyze the case where the secret $w$ is distributed uniformly over all subsets of size $s$. Second, they provide an analysis of a nonuniform password distribution, but only for the case $r=n$ (that is, their analysis applies only in the small universe setting, where $\Omega(n)$ storage is acceptable). Here we give a simpler analysis which handles nonuniformity and any $r\leq n$. We get the same results for a broader set of parameters.

Lemma D.1.

The entropy loss of the Juels-Sudan scheme is at most $t\log n+\log{\binom{n}{r}}-\log{\binom{n-s}{r-s}}+2$.

Proof.

This is a simple application of Lemma 2.2(b). ${\mathbf{H}_{\infty}}((W,\mathsf{SS}(W)))$ can be computed as follows. Choosing the polynomial $p$ (which can be uniquely recovered from $w$ and $\mathsf{SS}(w)$) requires $s-t$ random choices from ${\cal F}$. The choice of the remaining $x_{i}$’s requires $\log{\binom{n-s}{r-s}}$ bits, and choosing the $y_{i}^{\prime}s$ requires $r-s$ random choices from ${\cal F}-\left\{{p(x_{i})}\right\}$. Thus, ${\mathbf{H}_{\infty}}((W,\mathsf{SS}(W)))={\mathbf{H}_{\infty}}(W)+(s-t)\log n+\log{\binom{n-s}{r-s}}+(r-s)\log(n-1)$. The output can be described in $\log\left({{\binom{n}{r}}n^{r}}\right)$ bits. The result follows by Lemma 2.2(b) after observing that $(r-s)\log\frac{n}{n-1}<n\log\frac{n}{n-1}\leq 2$. ∎

In the large universe setting, we will have $r\ll n$ (since we wish to have storage polynomial in $s$). In that setting, the bound on the entropy loss of the Juels-Sudan scheme is in fact very large. We can rewrite the entropy loss as $t\log n-\log{\binom{r}{s}}+\log{\binom{n}{s}}+2$, using the identity ${\binom{n}{r}}{\binom{r}{s}}={\binom{n}{s}}{\binom{n-s}{r-s}}$. Now the entropy of $W$ is at most ${\binom{n}{s}}$, and so our lower bound on the remaining entropy is $(\log{\binom{r}{s}}-t\log n-2)$. To make this quantity large requires making $r$ very large.

Appendix E BCH Syndrome Decoding in Sublinear Time

We show that the standard decoding algorithm for BCH codes can be modified to run in time polynomial in the length of the syndrome. This works for BCH codes over any field $\mathit{GF}(q)$, which include Hamming codes in the binary case and Reed-Solomon for the case $n=q-1$. BCH codes are handled in detail in many textbooks (e.g., [vL92]); our presentation here is quite terse. For simplicity, we discuss only primitive, narrow-sense BCH codes here; the discussion extends easily to the general case.

The algorithm discussed here has been revised due to an error pointed out by Ari Trachtenberg. Its implementation is available [HJR06].

We’ll use a slightly nonstandard formulation of BCH codes. Let $n=q^{m}-1$ (in the binary case of interest in Section 6.3, $q=2$). We will work in two finite fields: $\mathit{GF}(q)$ and a larger extension field ${\cal F}=\mathit{GF}(q^{m})$. BCH codewords, formally defined below, are then vectors in $\mathit{GF}(q)^{n}$. In most common presentations, one indexes the $n$ positions of these vectors by discrete logarithms of the elements of ${\cal F}^{*}$: position $i$, for $1\leq i\leq n$, corresponds to $\alpha^{i}$, where $\alpha$ generates the multiplicative group ${\cal F}^{*}$. However, there is no inherent reason to do so: they can be indexed by elements of ${\cal F}$ directly rather than by their discrete logarithms. Thus, we say that a word has value $p_{x}$ at position $x$, where $x\in{\cal F}^{*}$. If one ever needs to write down the entire $n$-character word in an ordered fashion, one can arbitrarily choose a convenient ordering of the elements of ${\cal F}$ (e.g., by using some standard binary representation of field elements); for our purposes this is not necessary, as we do not store entire $n$-bit words explicitly, but rather represent them by their supports: ${\mathsf{supp}}(v)=\{(x,p_{x})\mid p_{x}\neq 0\}$. Note that for the binary case of interest in Section 6.3, we can define ${\mathsf{supp}}(v)=\{x\mid p_{x}\neq 0\}$, because $p_{x}$ can take only two values: 0 or 1.

Our choice of representation will be crucial for efficient decoding: in the more common representation, the last step of the decoding algorithm requires one to find the position $i$ of the error from the field element $\alpha^{i}$. However, no efficient algorithms for computing the discrete logarithm are known if $q^{m}$ is large (indeed, a lot of cryptography is based on the assumption that such an efficient algorithm does not exist). In our representation, the field element $\alpha^{i}$ will in fact be the position of the error.

Definition 8.

The (narrow-sense, primitive) BCH code of designed distance $\delta$ over $\mathit{GF}(q)$ (of length $n\geq\delta$) is given by the set of vectors of the form $\big{(}c_{x}\big{)}_{x\in{\cal F}^{*}}$ such that each $c_{x}$ is in the smaller field $\mathit{GF}(q)$, and the vector satisfies the constraints $\sum_{x\in{\cal F}^{*}}c_{x}x^{i}=0$, for $i=1,\ldots,\delta-1$, with arithmetic done in the larger field ${\cal F}$.

To explain this definition, let us fix a generator $\alpha$ of the multiplicative group of the large field ${\cal F}^{*}$. For any vector of coefficients $\big{(}c_{x}\big{)}_{x\in{\cal F}^{*}}$, we can define a polynomial

$$c(z)=\sum_{x\in\mathit{GF}(q^{m})^{*}}c_{x}z^{\mathsf{dlog}(x)}\,,$$

where $\mathsf{dlog}(x)$ is the discrete logarithm of $x$ with respect to $\alpha$. The conditions of the definition are then equivalent to the requirement (more commonly seen in presentations of BCH codes) that $c(\alpha^{i})=0$ for $i=1,\ldots,\delta-1$, because $(\alpha^{i})^{\mathsf{dlog}(x)}=(\alpha^{\mathsf{dlog}(x)})^{i}=x^{i}$.

We can simplify this somewhat. Because the coefficients $c_{x}$ are in $\mathit{GF}(q)$, they satisfy $c_{x}^{q}=c_{x}$. Using the identity $(x+y)^{q}=x^{q}+y^{q}$, which holds even in the large field ${\cal F}$, we have $c(\alpha^{i})^{q}=\sum_{x\neq 0}c_{x}^{q}x^{iq}=c(\alpha^{iq})$. Thus, roughly a $1/q$ fraction of the conditions in the definition are redundant: we need only to check that they hold for $i\in\left\{{1,\dots,\delta-1}\right\}$ such that $q\not|i$.

The syndrome of a word (not necessarily a codeword) $(p_{x})_{x\in{\cal F}^{*}}\in\mathit{GF}(q)^{n}$ with respect to the BCH code above is the vector

$${\mathsf{syn}}(p)=p(\alpha^{1}),\ldots,p(\alpha^{\delta-1}),\quad\text{where}\quad p(\alpha^{i})=\sum_{x\in{\cal F}^{*}}p_{x}x^{i}.$$

As mentioned above, we do not in fact have to include the values $p(\alpha^{i})$ such that $q|i$.

Computing with Low-Weight Words.  A low-weight word $p\in\mathit{GF}(q)^{n}$ can be represented either as a long string or, more compactly, as a list of positions where it is nonzero and its values at those points. We call this representation the support list of $p$ and denote it ${\mathsf{supp}}(p)=\left\{{(x,p_{x})}\right\}_{x:p_{x}\neq 0}$.

Lemma E.1.

For a $q$-ary BCH code $C$ of designed distance $\delta$, one can compute:

• ${\mathsf{syn}}(p)$ from ${\mathsf{supp}}(p)$ in time polynomial in $\delta$, $\log n$, and $|{\mathsf{supp}}(p)|$, and

• ${\mathsf{supp}}(p)$ from ${\mathsf{syn}}(p)$ (when $p$ has weight at most $(\delta-1)/2$), in time polynomial in $\delta$ and $\log n$.

Proof.

Recall that ${\mathsf{syn}}(p)=(p(\alpha),\dots,p(\alpha^{\delta-1}))$ where $p(\alpha^{i})=\sum_{x\neq 0}p_{x}x^{i}$. Part (1) is easy, since to compute the syndrome we need only to compute the powers of $x$. This requires about $\delta\cdot{\mathsf{weight}}(p)$ multiplications in ${\cal F}$. For Part (2), we adapt Berlekamp’s BCH decoding algorithm, based on its presentation in [vL92]. Let $M=\left\{{x\in{\cal F}^{*}|p_{x}\neq 0}\right\}$, and define

$$\sigma(z)\stackrel{{\scriptstyle\rm def}}{{=}}\prod_{x\in M}(1-xz)\quad\mbox{and}\quad\omega(z)\stackrel{{\scriptstyle\rm def}}{{=}}\sigma(z)\sum_{x\in M}\frac{p_{x}xz}{(1-xz)}\,.$$

Since $(1-xz)$ divides $\sigma(z)$ for $x\in M$, we see that $\omega(z)$ is in fact a polynomial of degree at most $|M|={\mathsf{weight}}(p)\leq(\delta-1)/2$. The polynomials $\sigma(z)$ and $\omega(z)$ are known as the error locator polynomial and evaluator polynomial, respectively; observe that $\gcd(\sigma(z),\omega(z))=1$.

We will in fact work with our polynomials modulo $z^{\delta}$. In this arithmetic the inverse of $(1-xz)$ is $\sum_{\ell=1}^{\delta}(xz)^{\ell-1}$; that is,

$$(1-xz)\sum_{\ell=1}^{\delta}(xz)^{\ell-1}\equiv 1\mod z^{\delta}.$$

We are given $p(\alpha^{\ell})$ for $\ell=1,\dots,\delta$. Let $S(z)=\sum_{\ell=1}^{\delta-1}p(\alpha^{\ell})z^{\ell}$. Note that $S(z)\equiv\sum_{x\in M}p_{x}\frac{xz}{(1-xz)}\mod z^{\delta}$. This implies that

$$S(z)\sigma(z)\equiv\omega(z)\mod{z^{\delta}}.$$

The polynomials $\sigma(z)$ and $\omega(z)$ satisfy the following four conditions: they are of degree at most $(\delta-1)/2$ each, they are relatively prime, the constant coefficient of $\sigma$ is 1, and they satisfy this congruence. In fact, let $w^{\prime}(z),\sigma^{\prime}(z)$ be any nonzero solution to this congruence, where degrees of $w^{\prime}(z)$ and $\sigma^{\prime}(z)$ are at most $(\delta-1)/2$. Then $w^{\prime}(z)/\sigma^{\prime}(z)=\omega(z)/\sigma(z)$. (To see why this is so, multiply the initial congruence by $\sigma^{\prime}()$ to get $\omega(z)\sigma^{\prime}(z)\equiv\sigma(z)\omega^{\prime}(z)\mod z^{\delta}$. Since both sides of the congruence have degree at most $\delta-1$, they are in fact equal as polynomials.) Thus, there is at most one solution $\sigma(z),\omega(z)$ satisfying all four conditions, which can be obtained from any $\sigma^{\prime}(z),\omega^{\prime}(z)$ by reducing the resulting fraction $\omega^{\prime}(z)/\sigma^{\prime}(z)$ to obtain the solution of minimal degree with the constant term of $\sigma$ equal to 1.

Finally, the roots of $\sigma(z)$ are the points $x^{-1}$ for $x\in M$, and the exact value of $p_{x}$ can be recovered from $\omega(x^{-1})=p_{x}\prod_{y\in M,y\neq x}(1-yx^{-1})$ (this is needed only for $q>2$, because for $q=2$, $p_{x}=1$). Note that it is possible that a solution to the congruence will be found even if the input syndrome is not a syndrome of any $p$ with ${\mathsf{weight}}(p)>(\delta-1)/2$ (it is also possible that a solution to the congruence will not be found at all, or that the resulting $\sigma(z)$ will not split into distinct nonzero roots). Such a solution will not give the correct $p$. Thus, if there is no guarantee that ${\mathsf{weight}}(p)$ is actually at most $(\delta-1)/2$, it is necessary to recompute ${\mathsf{syn}}(p)$ after finding the solution, in order to verify that $p$ is indeed correct.

Representing coefficients of $\sigma^{\prime}(z)$ and $\omega^{\prime}(z)$ as unknowns, we see that solving the congruence requires only solving a system of $\delta$ linear equations (one for each degree of $z$, from 0 to $\delta-1$) involving $\delta+1$ variables over ${\cal F}$, which can be done in $O(\delta^{3})$ operations in ${\cal F}$ using, e.g., Gaussian elimination. The reduction of the fraction $\omega^{\prime}(z)/\sigma^{\prime}(z)$ requires simply running Euclid’s algorithm for finding the g.c.d. of two polynomials of degree less than $\delta$, which takes $O(\delta^{2})$ operations in ${\cal F}$. Suppose the resulting $\sigma$ has degree $e$. Then one can find the roots of $\sigma$ as follows. First test that $\sigma$ indeed has $e$ distinct roots by testing that $\sigma(z)|z^{q^{m}}-z$ (this is a necessary and sufficient condition, because every element of ${\cal F}$ is a root of $z^{q^{m}}-z$ exactly once). This can be done by computing $(z^{q^{m}}\bmod\sigma(z))$ and testing if it equals $z\bmod\sigma$; it takes $m$ exponentiations of a polynomial to the power $q$, i.e., $O((m\log q)e^{2})$ operations in ${\cal F}$. Then apply an equal-degree-factorization algorithm (e.g., as described in [Sho05]), which also takes $O((m\log q)e^{2})$ operations in ${\cal F}$. Finally, after taking inverses of the roots of ${\cal F}$ and finding $p_{x}$ (which takes $O(e^{2})$ operations in ${\cal F}$), recompute ${\mathsf{syn}}(p)$ to verify that it is equal to the input value.

Because $m\log q=\log(n+1)$ and $e\leq(\delta-1)/2$, the total running time is $O(\delta^{3}+\delta^{2}\log n)$ operations in ${\cal F}$; each operation in ${\cal F}$ can done in time $O(\log^{2}n)$, or faster using advanced techniques.

One can improve this running time substantially. The error locator polynomial $\sigma()$ can be found in $O(\log\delta)$ convolutions (multiplications) of polynomials over ${\cal F}$ of degree $(\delta-1)/2$ each [Bla83, Section 11.7] by exploiting the special structure of the system of linear equations being solved. Each convolution can be performed asymptotically in time $O(\delta\log\delta\log\log\delta)$ (see, e.g., [vzGG03]), and the total time required to find $\sigma$ gets reduced to $O(\delta\log^{2}\delta\log\log\delta)$ operation in ${\cal F}$. This replaces the $\delta^{3}$ term in the above running time.

While this is asymptotically very good, Euclidean-algorithm-based decoding [SKHN75], which runs in $O(\delta^{2})$ operations in ${\cal F}$, will find $\sigma(z)$ faster for reasonable values of $\delta$ (certainly for $\delta<1000)$. The algorithm finds $\sigma$ as follows:

set ${R_{\mathrm{old}}}(z)\leftarrow z^{\delta-1}$, ${R_{\mathrm{cur}}}(z)\leftarrow S(z)/z$, ${V_{\mathrm{old}}}(z)\leftarrow 0$, ${V_{\mathrm{cur}}}(z)\leftarrow 1$.
while $\deg({R_{\mathrm{cur}}}(z))\geq(\delta-1)/2$:
	divide ${R_{\mathrm{old}}}(z)$ by ${R_{\mathrm{cur}}}(z)$ to get quotient $q(z)$ and remainder ${R_{\mathrm{new}}}(z)$;
	set ${V_{\mathrm{new}}}(z)\leftarrow{V_{\mathrm{old}}}(z)-q(z){V_{\mathrm{cur}}}(z)$;
	set ${R_{\mathrm{old}}}(z)\leftarrow{R_{\mathrm{cur}}}(z),{R_{\mathrm{cur}}}(z)\leftarrow{R_{\mathrm{new}}}(z),{V_{\mathrm{old}}}(z)\leftarrow{V_{\mathrm{cur}}}(z),$ ${V_{\mathrm{cur}}}(z)\leftarrow{V_{\mathrm{new}}}(z)$.
set $c\leftarrow{V_{\mathrm{cur}}}(0)$; set $\sigma(z)\leftarrow{V_{\mathrm{cur}}}(z)/c$ and $\omega(z)\leftarrow z\cdot{R_{\mathrm{cur}}}(z)/c$

In the above algorithm, if $c=0$, then the correct $\sigma(z)$ does not exist, i.e., ${\mathsf{weight}}(p)>(\delta-1)/2$. The correctness of this algorithm can be seen by observing that the congruence $S(z)\sigma(z)\equiv\omega(z)\pmod{z^{\delta}}$ can have $z$ factored out of it (because $S(z)$, $\omega(z)$ and $z^{\delta}$ are all divisible by $z$) and rewritten as $(S(z)/z)\sigma(z)+u(z)z^{\delta-1}=\omega(z)/z$, for some $u(z)$. The obtained $\sigma$ is easily shown to be the correct one (if one exists at all) by applying [Sho05, Theorem 18.7] (to use the notation of that theorem, set $n=z^{\delta-1},y=S(z)/z,t^{*}=r^{*}=(\delta-1)/2,r^{\prime}=\omega(z)/z,s^{\prime}=u(z),t^{\prime}=\sigma(z)$).

The root finding of $\sigma$ can also be sped up. Asymptotically, detecting if a polynomial over ${\cal F}=\mathit{GF}(q^{m})=\mathit{GF}(n+1)$ of degree $e$ has $e$ distinct roots and finding these roots can be performed in time $O(e^{1.815}(\log n)^{0.407})$ operations in ${\cal F}$ using the algorithm of Kaltofen and Shoup [KS95], or in time $O(e^{2}+(\log n)e\log e\log\log e)$ operations in ${\cal F}$ using the EDF algorithm of Cantor and Zassenhaus. For reasonable values of $e$, the Cantor-Zassenhaus EDF algorithm with Karatsuba’s multiplication algorithm [KO63] for polynomials will be faster, giving root-finding running time of $O(e^{2}+e^{\log_{2}3}\log n)$ operations in ${\cal F}$. Note that if the actual weight $e$ of $p$ is close to the maximum tolerated $(\delta-1)/2$, then finding the roots of $\sigma$ will actually take longer than finding $\sigma$. ∎

A Dual View of the Algorithm.  Readers may be used to seeing a different, evaluation-based formulation of BCH codes, in which codewords are generated as follows. Let ${\cal F}$ again be an extension of $\mathit{GF}(q)$, and let $n$ be the length of the code (note that $|{\cal F}^{*}|$ is not necessarily equal to $n$ in this formulation). Fix distinct $x_{1},x_{2},\dots,x_{n}\in{\cal F}$. For every polynomial $c$ over the large field ${\cal F}$ of degree at most $n-\delta$, the vector $(c(x_{1}),c(x_{2}),\dots c(x_{n}))$ is a codeword if and only if every coordinate of the vector happens to be in the smaller field: $c(x_{i})\in\mathit{GF}(q)$ for all $i$. In particular, when ${\cal F}=\mathit{GF}(q)$, then every polynomial leads to a codeword, thus giving Reed-Solomon codes.

The syndrome in this formulation can be computed as follows: given a vector $y=(y_{1},y_{2},\dots,y_{n})$ find the interpolating polynomial $P=p_{n-1}x^{n-1}+p_{n-2}x^{n-2}+\dots+p_{0}$ over ${\cal F}$ of degree at most $n-1$ such that $P(x_{i})=y_{i}$ for all $i$. The syndrome is then the negative top $\delta-1$ coefficients of $P$: ${\mathsf{syn}}(y)=(-p_{n-1},-p_{n-2},\dots,-p_{n-(\delta-1)})$. (It is easy to see that this is a syndrome: it is a linear function that is zero exactly on the codewords.)

When $n=|{\cal F}|-1$, we can index the $n$-component vectors by elements of ${\cal F}^{*}$, writing codewords as $(c(x))_{x\in{\cal F}^{*}}$. In this case, the syndrome of $(y_{x})_{x\in{\cal F}^{*}}$ defined as the negative top $\delta-1$ coefficients of $P$ such that for all $x\in F^{*},P(x)=y_{x}$ is equal to the syndrome defined following Definition 8 as $\sum_{x\in{\cal F}}y_{x}x^{i}$ for $i=1,2,\dots,\delta-1$. Thus, when $n=|{\cal F}|-1$, the codewords obtained via the evaluation-based definition are identical to the codewords obtain via Definition 8, because codewords are simply elements with the zero syndrome, and the syndrome maps agree.

This is an example of a remarkable duality between evaluations of polynomials and their coefficients: the syndrome can be viewed either as the evaluation of a polynomial whose coefficients are given by the vector, or as the coefficients of the polynomial whose evaluations are given by a vector.

The syndrome decoding algorithm above has a natural interpretation in the evaluation-based view. Our presentation is an adaptation of Welch-Berlekamp decoding as presented in, e.g., [Sud01, Chapter 10].

Suppose $n=|F|-1$ and $x_{1},\dots,x_{n}$ are the nonzero elements of the field. Let $y=(y_{1},y_{2},\dots,y_{n})$ be a vector. We are given its syndrome ${\mathsf{syn}}(y)=(-p_{n-1},-p_{n-2},\dots,\allowbreak-p_{n-(\delta-1)})$, where $p_{n-1},\dots,p_{n-(\delta-1)}$ are the top coefficients of the interpolating polynomial $P$. Knowing only ${\mathsf{syn}}(y)$, we need to find at most $(\delta-1)/2$ locations $x_{i}$ such that correcting all the corresponding $y_{i}$ will result in a codeword. Suppose that codeword is given by a degree-$(n-\delta)$ polynomial $c$. Note that $c$ agrees with $P$ on all but the error locations. Let $\rho(z)$ be the polynomial of degree at most $(\delta-1)/2$ whose roots are exactly the error locations. (Note that $\sigma(z)$ from the decoding algorithm above is the same $\rho(z)$ but with coefficients in reverse order, because the roots of $\sigma$ are the inverses of the roots of $\rho$.) Then $\rho(z)\cdot P(z)=\rho(z)\cdot c(z)$ for $z=x_{1},x_{2},\dots,x_{n}$. Since $x_{1},\dots,x_{n}$ are all the nonzero field elements, $\prod_{i=1}^{n}(z-x_{i})=z^{n}-1$. Thus,

$$\rho(z)\cdot c(z)\quad=\quad\rho(z)\cdot P(z)\bmod\prod_{i=1}^{n}(z-x_{i})\quad=\quad\rho(z)\cdot P(z)\bmod(z^{n}-1)\,.$$

If we write the left-hand side as $\alpha_{n-1}x^{n-1}+\alpha_{n-2}x^{n-2}+\cdots+\alpha_{0}$, then the above equation implies that $\alpha_{n-1}=\cdots=\alpha_{n-(\delta-1)/2}=0$ (because the degree if $\rho(z)\cdot c(z)$ is at most $n-(\delta+1)/2$). Because $\alpha_{n-1},\dots,\alpha_{n-(\delta-1)/2}$ depend on the coefficients of $\rho$ as well as on $p_{n-1},\dots,p_{n-(\delta-1)}$, but not on lower coefficients of $P$, we obtain a system of $(\delta-1)/2$ equations for $(\delta-1)/2$ unknown coefficients of $\rho$. A careful examination shows that it is essentially the same system as we had for $\sigma(z)$ in the algorithm above. The lowest-degree solution to this system is indeed the correct $\rho$, by the same argument which was used to prove the correctness of $\sigma$ in Lemma E.1. The roots of $\rho$ are the error-locations. For $q>2$, the actual corrections that are needed at the error locations (in other words, the light vector corresponding to the given syndrome) can then be recovered by solving the linear system of equations implied by the value of the syndrome.